././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2534177 python-rtmidi-1.4.7/0000755000175000001440000000000000000000000013362 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611775847.0 python-rtmidi-1.4.7/.gitignore0000644000175000001440000000106600000000000015355 0ustar00chrisusers# Python bytecode *.py[cod] __pycache__ # Cython output src/_rtmidi.cpp # C extensions *.so # Generated documentation #INSTALL.rst # Packages *.egg *.egg-info dist/ build/ *.eggs/ eggs/ parts/ .installed.cfg setuptools-*.tar.gz distribute-*.tar.gz MANIFEST # Installer logs pip-log.txt # Unit test / coverage reports .cache/ .coverage .pytest_cache/ .tox/ nosetests.xml htmlcov # Translations *.mo # Misc IDEs .mr.developer.cfg .project .pydevproject # Complexity output/*.html output/*/index.html # Sphinx docs/_build # Geany project python-rtmidi.geany ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/.gitmodules0000644000175000001440000000016600000000000015542 0ustar00chrisusers[submodule "src/rtmidi"] path = src/rtmidi url = https://github.com/SpotlightKid/rtmidi.git branch = python-rtmidi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/AUTHORS.rst0000644000175000001440000000042200000000000015237 0ustar00chrisusers======= Credits ======= Development Lead ---------------- * Christopher Arndt Contributors ------------ * Michiel Overtoom * Orhan Kavrakoğlu * tekHedd * Maurizio Berti * Benoit Pierre Testing ------- * Martin Tarenskeen * Pierre Castellotti ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611776159.0 python-rtmidi-1.4.7/CHANGELOG.rst0000644000175000001440000005165400000000000015416 0ustar00chrisusersChangelog ========= For details and minor changes, please see the `version control log messages `_. 2021-01-27 version 1.4.7 ------------------------ Fixes: * Fixed compiler deprecation warning about ``PyEval_InitThreads`` on Python 3.9+. Examples: * Added ``send_sysex`` and ``send_sysex_file`` example scripts. Documentation: * Remove references to old project homepage URL and fix readme badges. 2020-10-15 version 1.4.6 ------------------------ Project infrastructure: * Declared/documented Python 3.9 support and updated CI. * Dropped official support for Python 3.5. * Updated Python versions for building macOS binary wheels. 2020-08-26 version 1.4.5 ------------------------ Fixes: * Revert to old way of reading version number via ``exec`` (see 8d9a8f9 for background info). 2020-08-26 version 1.4.4 ------------------------ Fixes: * Fixed ``setup.py`` to work with Python 2 again, though it is not officially supported anymore (#70, #72). 2020-08-11 version 1.4.3 ------------------------ Fixes: * Fixed error when trying to import version number from ``rtmidi.release`` when Python is running with ``-OO`` optimization enabled (#69). Project infrastructure: * Moved distribution meta data to ``setup.cfg``, added ``rtmidi/version.py`` and removed ``rtmidi/release.py`` (#69). 2020-07-18 version 1.4.2 ------------------------ Enhancements: * Added more helpful aliases for MIDI events/controllers constants. Examples: * Added ``ccstore`` advanced example to show how to remember last seen controller change values (#64). 2020-04-16 version 1.4.1 ------------------------ Changes: * Suppress RtMidi warnings to stderr, so that warnings issued in the constructor of the ``RtMidiIn/Out`` C++ class instances before the default error handler function can be attached, don't end up in the output. The suppression of RtMidi warnings can be disabled at compile time by setting the pre-compiler define ``__RTMIDI_SUPPRESS_WARNINGS__`` via a command line option to ``setup.py``. As before, RtMidi warnings are turned into Python a ``UserWarning`` as soon as the default error handler is attached, but this can only happen after the RtMidi C++ class has been instantiated (#59). * Allow deletion of internal C++ RtMidiIn/Out instance via new ``delete`` method of ``rtmidi.MidiIn`` and ``rtmidi.MidiOut`` instances (but see warning in docstring!). Also added a ``is_deleted`` property to both classes (#60). 2020-01-19 version 1.4.0 ------------------------ Changes: * Dropped nominal Python 2 support (no code changes or removals related to this, though). * Dropped Python 3.4 support. * Added Python 3.8 to ``setup.py`` classifier. Enhancements: * Added ``MODULATION`` as an alias for ``MODULATION_WHEEL`` to ``rtmidi.midiconstants``. Examples: * Added ``midiclock`` example to show how to receive MIDI timing clock (#48). * Changed ``midioutwrapper`` example to use ``rtmidi.midiutil.open_midiout`` so that it also works on Windows (with no virtual ports support) (#51). Documentation: * Added note about ``pip`` being called ``pip3`` on Debian-based systems to install instructions (#49). * Documented context manager protocol support better (#52). * Clarified purpose of ``data`` argument of ``MidiIn.set_callback`` (#55). * Updated year in copyright info in license file and Sphinx documentation. Project infrastructure: * Removed Python 2.7 from CI tests and package builds. * Added Python 3.8 to CI and package builds. 2019-10-15 version 1.3.1 ------------------------ Enhancements / Changes: * RtMidi C++ exceptions are now caught when creating ``RtMidiIn/Out`` instances and converted into a Python ``rtmidi.SystemError`` exception. * Helper functions in ``rtmidi.midiutil`` now raise sub-classes of ``rtmidi.RtMidiError`` wherever appropriate. The docstrings where updated accordingly. * Updated ``rtmidi`` sub-module, which includes the following changes: * C++ exceptions, when thrown, do not print the error message to stderr anymore. * When the JACK backend can't be initialized (e.g. when the server isn't running) it causes a ``DRIVER_ERROR`` instead of just a printing a ``WARNING``. Examples: * ``midiout.py``: removed surplus second argument to ``open_midioutput`` left over from previous version of script. * Renamed example script ``midiwrapper.py`` to ``midioutwrapper.py`` to better indicate its function. * ``sendsysex.py``: use helper functions from midiutil module to list and open MIDI ports; improve error handling. * Made sure MIDI ports are always properly closed and ``MidiIn/Out`` instances are deleted. * Inserted delay before closing/deleting output (may be needed with Windows MMS). * Simplified command line argument handling. * Fixed example script file names in header comments. Documentation: * Made various small documentation wording changes and typo fixes. * Updated year in copyright info in license file and Sphinx documentation. Project infrastructure: * Updated development dependency on ``urllib3`` to 1.24.2 (CVE-2019-11324). 2019-04-15 version 1.3.0 ------------------------ Enhancements / Changes: * Added ``get_api_display_name`` module-level function. * Added ``get_api_name`` module-level function. * Added ``get_compiled_api_by_name`` module-level function. * Updated ``rtmidi`` sub-module to include all changes from upstream up to commit 791dfea. Documentation: * Improved installation instructions and listed options recognized by ``setup.py``. 2019-01-18 version 1.2.1 ------------------------ Fixes: * Fixed build when compiling with JACK support, but JACK version is too old to have ``jack_port_rename`` function (#40). Project infrastructure: * Added Linux builds for Python 2.7 and 3.4 - 3.7 to Travis CI setup. 2019-01-13 version 1.2.0 ------------------------ Project infrastructure: * RtMidi Sources and header are now included as a git sub-module from the 'python-rtmidi' branch of a fork_ of the upstream RtMidi repository. This fork incorporates changes and fixes by pull requests to the upstream repository, which are (yet) unmerged, and some changes specific to python-rtmidi. Enhancements / Changes: * Added ``get_rtmidi_version`` module-level function. * Added ``set_client_name`` and ``set_port_name`` methods to ``MidiIn``'s and ``MidiOut``'s base class. * Added a bunch of new custom exceptions, all derived from ``RtMidiError``. * A default error handler callback is now set for ``MidiIn`` and ``MidiOut`` instances, which maps C++ level errors into custom Python exceptions. Examples: * Enhanced example script ``midiwrapper.py`` with methods for more MIDI messages, including sending all kinds of controller change and of (N)RPN messages. Fixes: * Fixed SysEx message reception in JACK backend in RtMidi: messages broken up over several events are now collected into a single event before being passed to the input callback or returned by ``MidiIn.get_message``. * Fixed missing MIDI message input filtering in JACK backend in RtMidi: ``MidiIn.ignoreTypes`` now works as intended. Testing: * Restructured tests in ``test_rtmidi`` and added tests for new methods. .. _fork: https://github.com/SpotlightKid/rtmidi 2018-10-10 version 1.1.2 ------------------------ Project infrastructure: * Added bagdes and link to documentation to README visible on GitHub page. * Tweaked project description wording. * Updated copyright year in various documentation files. Building: * Binary wheels for Windows and OS X for Python 2.7, 3.5 (only Windows), 3.6, and 3.7 are automatically built on AppVeyor resp. Travis CI and uploaded to PyPI when a new release tag is pushed to GitHub. Thanks to Benoit Pierre for the PR (#36). * Upload Gzip'ed instead Bzip'ed tarballs for source distributions to PyPI. * ``python setup.py test`` now runs ``tox``, so ``tests_require`` in ``setup.py`` is empty now. We want dependencies to be only handled by ``pip``, never by ``setuptools``. Documentation: * Minor additions, updates, fixes and wording tweaks. 2018-08-06 version 1.1.1 ------------------------ Building: * Rebuild ``src/_rtmidi.cpp`` with current Cython for Python 3.7 compatibility. * Remove testing with Python 3.3 environment from ``tox.ini`` and add Python 3.6 and 3.7. * Update dev requirements for Python 3.7 compatibility. * Upload releases with twine. Documentation: * Python 3.3 is not officially tested or supported anymore. 2017-04-21 version 1.1.0 ------------------------ Project infrastructure: * Updated project homepage URL; copyright year and link to docs in readme. Building: * Added script to automate updating github pages docs. Enhancements / Changes: * Synced with upstream RtMidi_ (2.1.1-907a94c). * Applied patch from https://github.com/thestk/rtmidi/pull/89. This means that when using the ALSA API port names are reported in the form ``: `` (this change was actually already in version 1.0.0). * Added new ``MidiIn`` / ``MidiOut`` method ``is_port_open``. * ``MidiIn`` / ``MidiOut`` constructors and ``open_port`` / ``open_virtual_port`` methods now raise ``TypeError`` when an invalid type is passed as the client resp. port name. Documentation: * Various small documentation improvements. Examples: * Basic examples: some clean-up, more comments, updated API usage. * Added new advanced example script ``midiwrapper.py``. * Added new advanced example script ``recvrpn.py``. * ``wavetablemodstep.py``: added command line param to set controller number. * ``midi2command``: Fixed wrong mock lru_cache substitution for Python < 3.2. 2016-11-07 version 1.0.0 ------------------------ Project infrastructure: * Added automatic documentation publishing on readthedocs.org. Documentation: * Added auto docs for MidiIn/MidiOut classes to sphinx docs. * Removed pre-release related information from installation docs. Building: * Added generated INSTALL.rst to repo to make ReadTheDocs integration work. Examples: * Added new example script ``panic.py``. 2016-10-09 version 1.0.0rc1 --------------------------- Project infrastructure: * Moved repository to Github. Fixes: * ``midiutil.open_midiport``: * Correctly report and log I/O direction and instance type. * Fix naming of virtual port. Enhancements / Changes: * Synced with upstream RtMidi_ (2.1.1-399a8ee). * ``midiutil``: * The function ``midiutil.open_port`` has been renamed to ``open_midiport``. * Added convenience functions ``open_midiinput`` and ``open_midioutput``, which wrap ``open_midiport``. * RtMidi API to use can be specified via the ``RTMIDI_API`` environment variable. Only used when ``API_UNSPECIFIED`` is passed for the ``api`` argument. Value should be one of the ``API_*`` constant names with out the ``API_`` prefix, e.g. ``UNIX_JACK`` for the Jack API. * Cython wrapper class hierarchy restructured to better match the underlying C++ classes and remove code duplication. * Some source code re-ordering was done. Documentation: * Added basic structure and initial content of Sphinx documentation. * Documented exceptions raised by ``MidiIn/Out.open_[virtual_]port()``. * Some docstring corrections and formatting fixes. Building: * Simplified ``setup.py`` by throwing out old compatibility stuff. * Explicitly call ``PyEval_InitThreads`` from Cython code instead of using undocumented compiler macro. Examples: * Moved `osc2midi` example into its own repository at https://github.com/SpotlightKid/osc2rtmidi.git * Add new ``sequencer`` example. * Add new ``noteon2osc`` example. * ``midifilter``: * Moved ``main.py`` to ``__main__.py``, removed old code and fixed command line args access. * Streamlined event matching. * Added ``CCToBankChange`` filter. * ``Queue`` module renamed to ``queue`` in Python 3. * Fixed opening of output port erroneously used ``"input"``. * Fixed positional command line args handling. * Set command name for argparse. * ``midi2command``: * Added README. * Added command line option to select backend API. * Catch errors when opening port. * Set client and port name. * Cache command lookup (Python 3.2+ only). * ``sysexsaver``: * Moved ``main.py`` to ``__main__.py``, some refactoring. * ``models.py``: Fixed wrong entry for manufacturer ``(0, 32, 81)``. * Moved module level code into ``main`` function. * Include model name in output file, if possible. * ``drumseq``: * Fixed global access in ``Sequencer`` class. * Use ``args.FileType`` for pattern command line args. 2014-06-11 version 0.5b1 ------------------------ Fixes: * Synced RtMidi_ code with git repo @ 2c7a6664d6, which fixed several issues (see https://github.com/thestk/rtmidi/issues?state=closed). * ``MidiIn/Out.open_virtual_port`` returns ``self`` for context manager support, consistent with ``MidiIn/Out.open_port``. * Fix Python <= 2.6 incompatible encode method call (python-rtmidi officially only supports Python >= 2.7). Thanks to Michiel Overtoom for reporting this. * Respect passed MIDI api when requesting MidiOut instance from ``midiutil.open_midiport``. .. _rtmidi: https://github.com/thestk/rtmidi Enhancements / Changes: * Support for Windows Kernel Streaming API was removed in RtMidi (it was broken anyway) and consequently in ``python-rtmidi`` as well. * Raise ``RtMidiError`` exception when trying to open a (virtual) port on a ``MidiIn/Out`` instance that already has an open (virtual) port. * Add some common synonyms for MIDI events and controllers and some source comments about controller usage to ``midiconstants`` module. Documentation: * Fix and clarify ``queue_size_limit`` default value in docstrings * Various docstring consistency improvements and minor fixes. Examples: * New example script ``midi2command.py``, which executes external commands on reception of configurable MIDI events, with example configuration. * New example directory ``drumseq`` with a simple drum pattern sequencer and example drum patterns. Thanks to Michiel Overtoom for the original script! 2013-11-10 version 0.4.3b1 -------------------------- Building: * Add numeric suffix to version number to comply with PEP 440. * Add missing ``fill_template.py`` to source distribution. * Set default setuptools version in ``ez_setup.py`` to 1.3.2, which contains fix for bug #99 mentioned below. Documentation: * Add note to installation guide about required ``--pre`` option with pip. 2013-11-07 version 0.4.2b ------------------------- Fixes: * Add missing ``API_*`` constant to list of exported names of ``_rtmidi`` module. Enhancements / Changes: * Change default value of ``encoding`` argument of ``get_ports`` and ``get_port_name`` methods to `"auto"`, which selects appropriate encoding based on system and backend API used. * Add ``api`` parameter to ``midiutil.open_midiport`` function to select backend API. * Make client name for ``MidiOut`` and `` MidiIn`` different again, because some backend APIs might require unique client names. Building: * Include workaround for setuptools bug (see bitbucket issue #99) in setup file. * Add custom distutils command to fill placeholders in ``INSTALL.rst.in`` template with release meta data. * Setuptools is now required, pure distutils won't work anymore, so removing the fallback import of ``setup`` from distutils. 2013-11-05 version 0.4.1b ------------------------- Building: * Include missing ``_rtmidi.cpp`` file in source distribution. Documentation: * Fill in release data placeholders in ``INSTALL.rst``. 2013-11-05 version 0.4b ----------------------- Fixes: * Fix string conversion in constructors and ``open_*`` methods. * Change default value ``queue_size_limit`` argument to ``MidiIn`` constructor to 1024. * Update version number in ``RtMidi.cpp/h`` to reflect actual code state. Enhancements / Changes: * Elevated development status to beta. * Allow ``MidiIn/Out.open_port`` methods to be used with the ``with`` statement and the port will be closed at the end of the block. * ``MidiIn``/``MidiOut`` and ``open*()`` methods: allow to specify ``None`` as client or port name to get the default names. * Move ``midiconstants`` module from examples into ``rtmidi`` package and added ``midiutil`` module. * ``midiutils.open_midiport``: * Allow to pass (substring of) port name as alternative to port number. * Re-raise ``EOFError`` and ``KeyboardInterrupt`` instead of using ``sys.exit()``. * Add ``client_name`` and ``port_name`` arguments. * Add ``use_virtual`` argument (default ``False``) to request opening of a virtual MIDI port. * Add ``interactive`` keyword argument (default ``True``) to disable interactive prompt for port. * Raise ``NotImplemented`` error when trying to open a virtual port with Windows MultiMedia API. * Change default name of virtual ports. Documentation: * Re-organize package description and installation instructions into several files and add separate text files with changelog and license information. * Add detailed instructions for compiling from source on Windows * Add docstrings to all methods and functions in ``_rtmidi`` module. * Add docstring for ``midiutils.open_midiport`` function. Examples: * Add new example package ``osc2midi``, a simple, uni-directional OSC to MIDI mapper. * New example script ``sendsysex.py`` to demonstrate sending of MIDI system exclusive messages. * New example script ``wavetablemodstep.py`` to demonstrate sending of MIDI control change messages. * New ``sysexsaver`` example. * Convert ``midifilter`` example script into a package. * Upgrade from ``optparse`` to ``argparse`` in example scripts. * Enable logging in test scripts. Building: * Switch from ``distribute`` back to ``setuptools``. * Include ``ez_setup.py`` in source distribution. * Include examples in source distribution. * Install ``osc2midi`` example as package and command line script. * Enable C++ exceptions on Windows build. 2013-01-23 version 0.3.1a ------------------------- Enhancements: * Increase sysex input buffer size for WinMM API again to 8192 (8k) bytes. Requested by Martin Tarenskeen. 2013-01-14 version 0.3a ----------------------- Bug fixes: * Add ``encoding`` parameter to ``get_port_name`` methods of ``MidiIn`` and ``MidiOut`` to be able to handle non-UTF-8 port names, e.g. on Windows (reported by Pierre Castellotti). * Add ``encoding`` parameter to ``get_ports`` method as well and pass it through to ``get_port_name``. Use it in the test scripts. Enhancements: * Increase sysex input buffer size for WinMM API to 4096 bytes. Examples: * Add new ``midifilter.py`` example script. Building: * Add ``setuptools``/``distribute`` support. 2012-07-22 version 0.2a ----------------------- Bug fixes: * Fix uninitialized pointer bug in ``RtMidi.cpp`` in 'MidiOutJack' class, which caused a warning in the jack process callback when creating a ``MidiOut`` instance with the JACK API. * ``testmidiin_*.py``: fix superfluous decoding of port name (caused error with Python 3). Enhancements: * Simplify some code, some things gleaned from rtmidi_python. * Documentation typo fixes and more information on Windows compilation. * Enhancements in test scripts: * ``test_probe_ports.py``: Catch exceptions when creating port. * ``test_midiin_*.py``: * Better error message for missing/invalid port number. * Show how to convert event delta time into absolute time when receiving input. Building: * Building on OS X 10.6.9 with CoreMIDI and JACK for OS X successfully tested and test run without errors. * WinMM support now compiles with Visual Studio 2008 Express and tests work under Windows XP SP3 32-bit. * Add command line option to exclude WinMM or WinKS API from compilation. * Add missing ``extra_compile_args`` to Extension kwargs in setup file. * Add ``library_dirs`` to Extension kwargs in setup file. * Use ``-frtti`` compiler option on OS X (neccessary on 10.7?). * Fix file name conflict on case-insensitive file systems by prefixing ``rtmidi.{pyx,cpp}`` with an underscore * Provide correct compiler flags for compiling with Windows MultiMedia API. * Adapt windows library and include path for Visual Studio 2008 Express. * add support for compiling with Windows Kernel Streaming API (does not not compile due to syntax errors in RtMidi.cpp yet). 2012-07-13 version 0.1a ----------------------- First public release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/INSTALL-windows.rst0000644000175000001440000000754700000000000016727 0ustar00chrisusersHow to install python-rtmidi from source on Windows =================================================== These instruction should work for installing ``python-rtmidi`` from source Python 3.x in the 64-bit or 32-bit vsersions (you can run the latter on Windows 64-bit versions with no problems). Please follow all the steps below in the exact order. Installing required software ---------------------------- You probably need administrator rights for some or all of the following steps. #. Install the latest release of Python 3.6+ from https://www.python.org/downloads/windows/ to the default location (e.g. ``C:\Python36``). You can install either or both the 32-bit and the 64-bit version. In the installer, enable the option to install pip_. Optionally, *for only one of the chosen Python versions*, enable the options to add the installation directory to your ``PATH`` and set it as the system's default version. Also enable the option to install the ``py`` helper script (only available with some Python versions). #. Install virtualenv_ from a command prompt:: > python -m pip install -U virtualenv Repeat this for all Python versions you have installed (run ``py --help`` to get help on how to run different python version from the command line). #. Go to https://wiki.python.org/moin/WindowsCompilers and follow the instructions there to select and install the correct version(s) of the Visual C++ compiler for the version(s) of Python you installed. You can install several versions of Visual C++ at the same time. After installation, use Windows Update to get any pending security updates and fixes. Setting up a virtual environment -------------------------------- #. Open a command line and run:: > python -m virtualenv rtmidi > rtmidi\Scripts\activate #. Update pip and setuptools_ within your virtual environment to the latest versions with:: (rtmidi)> pip install -U pip setuptools #. Install Cython (still in the same command line window):: (rtmidi)> pip install Cython Download & unpack python-rtmidi source -------------------------------------- Get the latest python-rtmidi distribution as a Zip archive from https://pypi.python.org/pypi/python-rtmidi and unpack it somewhere. You can do the downloading and unpacking in one step using pip:: > pip install --no-install -d . "python-rtmidi" Alternatively, clone the python-rtmidi git repository:: > git clone https://github.com/SpotlightKid/python-rtmidi.git In the command line window you opened above, change into the ``python-rtmidi`` directory, which you created by unpacking the source or cloning the repository:: (rtmidi)> cd python-rtmidi Build & install python-rtmidi ----------------------------- Just run the usual setup command from within the source directory with the active virtual environment, i.e. from still the same command line window:: (rtmidi)> python setup.py install Verify your installation ------------------------ Change out of the ``python-rtmidi`` source directory (important!) and run:: (rtmidi)> cd .. (rtmidi)> python >>> import rtmidi >>> rtmidi.API_WINDOWS_MM in rtmidi.get_compiled_api() True >>> midiout = rtmidi.MidiOut() >>> midiout.get_ports() ['Microsoft GS Wavetable Synth'] If you have any other MIDI outputs (hardware MIDI interfaces, MIDI Yoke etc.) active, they should be listed by ``get_ports()`` as well. *That's it, congratulations!* Notes ----- Windows Kernel Streaming support in RtMidi has been removed (it was broken anyway) and consequently in ``python-rtmidi`` as well. Compiling with MinGW also does not work out-of-the-box yet. If you have any useful hints, please let the author know. .. _pip: https://pypi.python.org/pypi/pip .. _setuptools: https://pypi.python.org/pypi/setuptools .. _virtualenv: https://pypi.python.org/pypi/virtualenv ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779482.0 python-rtmidi-1.4.7/INSTALL.rst0000644000175000001440000002311300000000000015222 0ustar00chrisusers============ Installation ============ **python-rtmidi** uses the de-facto standard Python distutils and setuptools_ based packaging system and can be installed from the Python Package Index via pip_. Since it is a Python C(++)-extension, a C++ compiler and build environment as well as some system-dependent libraries are needed to install, unless wheel packages with pre-compiled binaries are available for your system. See the Requirements_ section below for details. From PyPI --------- If you have all the requirements_, you should be able to install the package with pip_:: $ pip install python-rtmidi This will download the source distribution from python-rtmidi's `PyPI page`_, compile the extension (if no pre-compiled binary wheel is available) and install it in your active Python installation. Unless you want to change the Cython_ source file ``_rtmidi.pyx``, there is no need to have Cython installed. .. note:: On some Linux distributions, e.g. *Debian*, which support both Python 2 and Python 3, pip may installed under the name ``pip2`` resp. ``pip3``. In this case, just ``pip2`` instead of ``pip`` if you're still using Python 2 (not officially supported), or ``pip3`` if you are using Python 3. python-rtmidi also works well with virtualenv_ and virtualenvwrapper_. If you have both installed, creating an isolated environment for testing and/or using python-rtmidi is as easy as:: $ mkvirtualenv rtmidi (rtmidi)$ pip install python-rtmidi If you want to pass options to the build process, use pip's ``install-option`` option. See the `From Source`_ section below for available options. Pre-compiled Binaries --------------------- Pre-compiled binary wheels of the latest python-rtmidi version for Windows and macOS / OS X are available on PyPI for several major Python versions. If you install python-rtmidi via pip (see above), these wheels will be selected by pip automatically, if you have a compatible Python and Windows or macOS version. The Windows binary wheels are compiled with Windows MultiMedia API support and are available in 32-bit and 64-bit versions. The macOS / OS X binary wheels are compiled with CoreMIDI support and are only available in 64-bit versions for OS X 10.6 and later. If you need JACK support on OS X, you need to compile python-rtmidi yourself (see the macOS_ section below for details). From Source ----------- To compile python-rtmidi from source and install it manually without pip, you can either download a source distribution archive or check out the sources from the Git repository. While the steps to get the sources differ, the actual compilation step consists only of the usual ``python setup.py install`` command in both cases. ``setup.py`` recognizes several options to control which OS-dependent MIDI backends will be supported by the python-rtmidi extension binary it produces plus other options to control compilation of the RtMidi C++ library: +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ | Option | Linux | mac OS / OS X | Windows | Note | +=============================+===========+===============+===========+==========================================================+ | ``--no-alsa`` | supported | | | Don't compile in support for ALSA backend. | +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ | ``--no-jack`` | supported | supported | | Don't compile in support for JACK backend. | +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ | ``--no-coremidi`` | | supported | | Don't compile in support for CoreMIDI backend. | +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ | ``--no-winmm`` | | | supported | Don't compile in support for Windows MultiMedia backend. | +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ | ``--no-suppress-warnings`` | | | | Don't suppress RtMidi warnings to stderr. | +-----------------------------+-----------+---------------+-----------+----------------------------------------------------------+ Support for each OS dependent MIDI backend is only enabled when the required library and header files are actually present on the system. When the options passed to ``setup.py`` change, it may be necessary to remove previously built files by deleting the ``build`` directory. You can also pass these options to ``setup.py`` when using pip, by using its ``--install-option`` option, for example:: pip install python-rtmidi --install-option="--no-jack" From the Source Distribution ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To download the python-rtmidi source distribution archive for the current version, extract and install it, use the following commands:: $ pip download python-rtmidi $ tar -xzf python-rtmidi-1.4.7.tar.gz $ cd python-rtmidi-1.4.7 $ python setup.py install On Linux or macOS / OS X, if you want to install python-rtmidi into the system-wide Python library directory, you may have to prefix the last command with ``sudo``, e.g.:: $ sudo python setup.py install The recommended way, though, is to install python-rtmidi only for your current user (which pip does by default) or into a virtual environment:: $ python setup.py install --user From the Source Code Repository ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Alternatively, you can check out the python-rtmidi source code from the Git repository and then install it from your working copy. Since the repository does not include the C++ module source code pre-compiled from the Cython source, you'll also need to install Cython >= 0.28, either via pip or from its Git repository. Using virtualenv / virtualenvwrapper is strongly recommended in this scenario: Make a virtual environment:: $ mkvirtualenv rtmidi (rtmidi)$ cdvirtualenv Install Cython from PyPI:: (rtmidi)$ pip install Cython *or* from its Git repository:: (rtmidi)$ git clone https://github.com/cython/cython.git (rtmidi)$ cd cython (rtmidi)$ python setup.py install (rtmidi)$ cd .. Then install python-rtmidi:: (rtmidi)$ git clone https://github.com/SpotlightKid/python-rtmidi.git (rtmidi)$ cd python-rtmidi (rtmidi)$ git submodule update --init (rtmidi)$ python setup.py install .. _requirements: Requirements ============ Naturally, you'll need a C++ compiler and a build environment. See the platform-specific hints below. If you want to change the Cython source file ``_rtmidi.pyx`` or want to recompile ``_rtmidi.cpp`` with a newer Cython version, you'll need to install Cython >= 0.28. The ``_rtmidi.cpp`` file in the current source distribution (version 1.4.7) is tagged with:: /* Generated by Cython 0.29.21 */ RtMidi (and therefore python-rtmidi) supports several low-level MIDI frameworks on different operating systems. Only one of the available options needs to be present on the target system, but support for more than one can be compiled in. The setup script will try to detect available libraries and should use the appropriate compilations flags automatically. * Linux: ALSA, JACK * macOS (OS X): CoreMIDI, JACK * Windows: MultiMedia (MM) Linux ----- First you need a C++ compiler and the pthread library. Install the ``build-essential`` package on debian-based systems to get these. Then you'll need Python development headers and libraries. On debian-based systems, install the ``python-dev`` package. If you use the official installers from python.org you should already have these. To get ALSA support, you must install development files for the ``libasound2`` library (debian package: ``libasound2-dev``). For JACK support, install the ``libjack`` development files (if you are using Jack1, install ``libjack-dev``, if you are using Jack2, install ``libjack-jackd2-dev``). .. _macos: macOS (OS X) ------------ Install the latest Xcode version or ``g++`` from MacPorts or homebrew (untested). CoreMIDI support comes with installing Xcode. For JACK support, install `JackOSX`_ with the installer or build JACK from source. .. note:: If you have an old version of OS X and Xcode which still support building binaries for PPC, you'll have to tell distribute to build the package only for i386 and x86_64 architectures:: env ARCHFLAGS="-arch i386 -arch x86_64" python setup.py install Windows ------- Please see the detailed instructions for Windows in :doc:`install-windows`. User Contributed Documentation ------------------------------ The python-rtmidi wiki on GitHub contains some `user contributed documentation`_ for additional installation scenarios. Please check these, if you have trouble installing python-rtmidi in an uncommon or not-yet-covered environment. .. _pypi page: http://python.org/pypi/python-rtmidi#downloads .. _cython: http://cython.org/ .. _pip: http://python.org/pypi/pip .. _setuptools: http://python.org/pypi/setuptools .. _virtualenv: http://pypi.python.org/pypi/virtualenv .. _virtualenvwrapper: http://www.doughellmann.com/projects/virtualenvwrapper/ .. _jackosx: http://jackaudio.org/downloads/ .. _user contributed documentation: https://github.com/SpotlightKid/python-rtmidi/wiki/User-contributed-documentation ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/LICENSE.txt0000644000175000001440000000532300000000000015210 0ustar00chrisusersCopyright & License =================== python-rtmidi was written by Christopher Arndt, 2012 - 2020. The software is released unter the MIT License: Copyright (c) 2012 - 2020 Christopher Arndt Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. RtMidi is distributed under a modified MIT License: RtMidi: realtime MIDI i/o C++ classes Copyright (c) 2003-2019 Gary P. Scavone Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Any person wishing to distribute modifications to the Software is asked to send the modifications to the original developer so that they can be incorporated into the canonical version. This is, however, not a binding provision of this license. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611766006.0 python-rtmidi-1.4.7/MANIFEST.in0000644000175000001440000000072600000000000015125 0ustar00chrisusersinclude fill_template.py include LICENSE.txt include Makefile include requirements-dev.txt include tox.ini include *.rst include src/_rtmidi.pyx include src/_rtmidi.cpp include src/pyinit.h include src/rtmidi/RtMidi.cpp include src/rtmidi/RtMidi.h exclude .appveyor.yml exclude .travis.yml exclude *.rst.in graft examples graft tests prune ci recursive-exclude * __pycache__ recursive-exclude * *.py[co] recursive-include docs *.rst *.inc conf.py Makefile make.bat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611765368.0 python-rtmidi-1.4.7/Makefile0000644000175000001440000000353200000000000015025 0ustar00chrisusers.PHONY: clean-pyc clean-build docs clean PYTHON ?= python SOURCES = src/_rtmidi.pyx src/rtmidi/RtMidi.cpp help: @echo "build - build extension module (and place it in the rtmidi package)" @echo "check-docs - check docstrings with pycodestyle" @echo "clean-build - remove build artifacts" @echo "clean-docs - remove docs output" @echo "clean-pyc - remove Python file artifacts" @echo "coverage - check code coverage quickly with the default Python" @echo "dist - build distribution packages" @echo "docs - generate Sphinx HTML documentation, including API docs" @echo "lint - check style with flake8" @echo "release - package a release" @echo "release_upload - package a release and upload it to PyPI" @echo "test - run tests on every supported Python version with tox" build: $(SOURCES) $(PYTHON) setup.py build_ext --inplace check-docs: pydocstyle rtmidi src clean: clean-build clean-docs clean-pyc rm -fr htmlcov/ clean-build: rm -fr build/ rm -fr dist/ rm -fr *.egg-info rm -fr rtmidi/*.so rm -fr src/_rtmidi.cpp clean-docs: rm -fr docs/_build clean-pyc: find . -name '*.pyc' -exec rm -f {} + find . -name '*.pyo' -exec rm -f {} + find . -name '*~' -exec rm -f {} + find . -name __pycache__ -type d -exec rm -rf {} + coverage: coverage run --source rtmidi setup.py test coverage report -m coverage html xdg-open htmlcov/index.html dist: clean release ls -l dist docs: release rm -f docs/rtmidi.rst rm -f docs/modules.rst $(PYTHON) setup.py build_ext --inplace sphinx-apidoc -o docs/ rtmidi rtmidi/release.py cat docs/api.rst.inc >> docs/rtmidi.rst $(MAKE) -C docs clean $(MAKE) -C docs html xdg-open docs/_build/html/index.html lint: flake8 rtmidi tests examples release: clean $(PYTHON) setup.py release release_upload: release twine upload --skip-existing dist/*.tar.gz test: PYTHONPATH=examples $(PYTHON) setup.py test ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2534177 python-rtmidi-1.4.7/PKG-INFO0000644000175000001440000001237000000000000014462 0ustar00chrisusersMetadata-Version: 1.1 Name: python-rtmidi Version: 1.4.7 Summary: A Python binding for the RtMidi C++ library implemented using Cython. Home-page: https://github.com/SpotlightKid/python-rtmidi Author: Christopher Arndt Author-email: chris@chrisarndt.de License: MIT License Download-URL: https://pypi.python.org/pypi/python-rtmidi Description: Welcome to python-rtmidi! ========================= A Python binding for the RtMidi C++ library implemented using Cython. |version| |status| |license| |python_versions| |format| |travis| .. |version| image:: https://shields.io/pypi/v/python-rtmidi :target: https://pypi.org/project/python-rtmidi :alt: Latest version .. |release-date| image:: https://shields.io/github/release-date/SpotlightKid/python-rtmidi :target: https://github.com/SpotlightKid/python-rtmidi/releases :alt: Date of latest release .. |status| image:: https://shields.io/pypi/status/python-rtmidi :alt: Project status .. |license| image:: https://shields.io/pypi/l/python-rtmidi :target: license.txt_ :alt: MIT License .. |python_versions| image:: https://shields.io/pypi/pyversions/python-rtmidi :alt: Python versions .. |format| image:: https://shields.io/pypi/format/python-rtmidi :target: https://pypi.org/project/python-rtmidi/#files :alt: Distribution format .. |travis| image:: https://travis-ci.org/SpotlightKid/python-rtmidi.svg?branch=master :target: https://travis-ci.org/SpotlightKid/python-rtmidi :alt: Travis CI status Overview ======== RtMidi_ is a set of C++ classes which provides a concise and simple, cross-platform API (Application Programming Interface) for realtime MIDI input / output across Linux (ALSA & JACK), macOS / OS X (CoreMIDI & JACK), and Windows (MultiMedia System) operating systems. python-rtmidi_ is a Python binding for RtMidi implemented using Cython_ and provides a thin wrapper around the RtMidi C++ interface. The API is basically the same as the C++ one but with the naming scheme of classes, methods and parameters adapted to the Python PEP-8 conventions and requirements of the Python package naming structure. **python-rtmidi** supports Python 3 (3.6, 3.7, 3.8, and 3.9). The documentation_ provides installation instructions, a history of changes per release and an API reference. See the file `LICENSE.txt`_ about copyright and usage terms. The source code repository and issue tracker are hosted on GitHub: https://github.com/SpotlightKid/python-rtmidi. Usage example ------------- Here's a quick example of how to use **python-rtmidi** to open the first available MIDI output port and send a middle C note on MIDI channel 1:: import time import rtmidi midiout = rtmidi.MidiOut() available_ports = midiout.get_ports() if available_ports: midiout.open_port(0) else: midiout.open_virtual_port("My virtual output") with midiout: note_on = [0x90, 60, 112] # channel 1, middle C, velocity 112 note_off = [0x80, 60, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout More usage examples can be found in the examples_ and tests_ directories of the source repository. .. _cython: http://cython.org/ .. _documentation: https://spotlightkid.github.io/python-rtmidi/ .. _examples: https://github.com/SpotlightKid/python-rtmidi/tree/master/examples .. _license.txt: https://github.com/SpotlightKid/python-rtmidi/blob/master/LICENSE.txt .. _python-rtmidi: https://github.com/SpotlightKid/python-rtmidi .. _rtmidi: http://www.music.mcgill.ca/~gary/rtmidi/index.html .. _tests: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests Keywords: midi,music,rtmidi Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: MacOS X Classifier: Environment :: Win32 (MS Windows) Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI Classifier: Topic :: Software Development :: Libraries :: Python Modules ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611760233.0 python-rtmidi-1.4.7/README.rst0000644000175000001440000000645700000000000015065 0ustar00chrisusersWelcome to python-rtmidi! ========================= A Python binding for the RtMidi C++ library implemented using Cython. |version| |status| |license| |python_versions| |format| |travis| .. |version| image:: https://shields.io/pypi/v/python-rtmidi :target: https://pypi.org/project/python-rtmidi :alt: Latest version .. |release-date| image:: https://shields.io/github/release-date/SpotlightKid/python-rtmidi :target: https://github.com/SpotlightKid/python-rtmidi/releases :alt: Date of latest release .. |status| image:: https://shields.io/pypi/status/python-rtmidi :alt: Project status .. |license| image:: https://shields.io/pypi/l/python-rtmidi :target: license.txt_ :alt: MIT License .. |python_versions| image:: https://shields.io/pypi/pyversions/python-rtmidi :alt: Python versions .. |format| image:: https://shields.io/pypi/format/python-rtmidi :target: https://pypi.org/project/python-rtmidi/#files :alt: Distribution format .. |travis| image:: https://travis-ci.org/SpotlightKid/python-rtmidi.svg?branch=master :target: https://travis-ci.org/SpotlightKid/python-rtmidi :alt: Travis CI status Overview ======== RtMidi_ is a set of C++ classes which provides a concise and simple, cross-platform API (Application Programming Interface) for realtime MIDI input / output across Linux (ALSA & JACK), macOS / OS X (CoreMIDI & JACK), and Windows (MultiMedia System) operating systems. python-rtmidi_ is a Python binding for RtMidi implemented using Cython_ and provides a thin wrapper around the RtMidi C++ interface. The API is basically the same as the C++ one but with the naming scheme of classes, methods and parameters adapted to the Python PEP-8 conventions and requirements of the Python package naming structure. **python-rtmidi** supports Python 3 (3.6, 3.7, 3.8, and 3.9). The documentation_ provides installation instructions, a history of changes per release and an API reference. See the file `LICENSE.txt`_ about copyright and usage terms. The source code repository and issue tracker are hosted on GitHub: https://github.com/SpotlightKid/python-rtmidi. Usage example ------------- Here's a quick example of how to use **python-rtmidi** to open the first available MIDI output port and send a middle C note on MIDI channel 1:: import time import rtmidi midiout = rtmidi.MidiOut() available_ports = midiout.get_ports() if available_ports: midiout.open_port(0) else: midiout.open_virtual_port("My virtual output") with midiout: note_on = [0x90, 60, 112] # channel 1, middle C, velocity 112 note_off = [0x80, 60, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout More usage examples can be found in the examples_ and tests_ directories of the source repository. .. _cython: http://cython.org/ .. _documentation: https://spotlightkid.github.io/python-rtmidi/ .. _examples: https://github.com/SpotlightKid/python-rtmidi/tree/master/examples .. _license.txt: https://github.com/SpotlightKid/python-rtmidi/blob/master/LICENSE.txt .. _python-rtmidi: https://github.com/SpotlightKid/python-rtmidi .. _rtmidi: http://www.music.mcgill.ca/~gary/rtmidi/index.html .. _tests: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/deploy.sh0000755000175000001440000000044300000000000015216 0ustar00chrisusers#!/bin/bash SRCDIR="$HOME/work/python-rtmidi/" DSTDIR="work/rtmidi/src/python-rtmidi" DSTHOST="192.168.100.1" rsync -av --update --checksum \ --exclude .svn \ --exclude sysex \ --exclude dist \ --exclude build \ --exclude __pycache__ \ "$SRCDIR" "$DSTHOST:$DSTDIR" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2444174 python-rtmidi-1.4.7/docs/0000755000175000001440000000000000000000000014312 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/Makefile0000644000175000001440000001517200000000000015760 0ustar00chrisusers# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/complexity.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/complexity.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/complexity" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/complexity" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/api.rst.inc0000644000175000001440000000136700000000000016374 0ustar00chrisusers Functions ~~~~~~~~~ .. autofunction:: get_api_name .. autofunction:: get_api_display_name .. autofunction:: get_compiled_api .. autofunction:: get_compiled_api_by_name .. autofunction:: get_rtmidi_version Exceptions ~~~~~~~~~~ .. autoclass:: rtmidi.RtMidiError :members: .. autoclass:: rtmidi.InvalidPortError :members: .. autoclass:: rtmidi.InvalidUseError :members: .. autoclass:: rtmidi.MemoryAllocationError :members: .. autoclass:: rtmidi.NoDevicesError :members: .. autoclass:: rtmidi.SystemError :members: .. autoclass:: rtmidi.UnsupportedOperationError :members: Classes ~~~~~~~ .. autoclass:: rtmidi.MidiIn :members: :inherited-members: .. autoclass:: rtmidi.MidiOut :members: :inherited-members: ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/authors.rst0000644000175000001440000000003400000000000016526 0ustar00chrisusers.. include:: ../AUTHORS.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/conf.py0000755000175000001440000002103600000000000015616 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # complexity documentation build configuration file, created by # sphinx-quickstart on Tue Jul 9 22:26:36 2013. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import configparser import sys import os # If extensions (or modules to document with autodoc) are in another # directory, add these directories to sys.path here. If the directory is # relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # Get the project root dir, which is the parent dir of this cwd = os.getcwd() project_root = os.path.dirname(cwd) # Insert the project root dir as the first element in the PYTHONPATH. # This lets us ensure that the source package is imported, and that its # version is used. sys.path.insert(0, project_root) meta = {} setupcfg = configparser.ConfigParser() setupcfg.read(os.path.join(project_root, 'setup.cfg')) version = os.path.join(project_root, 'rtmidi', 'version.py') exec(compile(open(version).read(), version, 'exec'), {}, meta) # -- General configuration --------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = setupcfg['metadata']['name'] copyright = u'2012 - 2020, %s' % setupcfg['metadata']['author'] # The version info for the project you're documenting, acts as replacement # for |version| and |release|, also used in various other places throughout # the built documents. # # The short X.Y version. version = meta['version'] # The full version, including alpha/beta/rc tags. release = meta['version'] # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to # some non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built # documents. #keep_warnings = False # -- Options for HTML output ------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'classic' # Theme options are theme-specific and customize the look and feel of a # theme further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as # html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the # top of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon # of the docs. This file should be a Windows icon file (.ico) being # 16x16 or 32x32 pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) # here, relative to this directory. They are copied after the builtin # static files, so a file named "default.css" will overwrite the builtin # "default.css". html_static_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page # bottom, using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names # to template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. # Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. # Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages # will contain a tag referring to it. The value of this option # must be the base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'rtmididoc' # -- Options for LaTeX output ------------------------------------------ latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [ ('index', 'rtmidi.tex', u'python-rtmidi Documentation', setupcfg['metadata']['author'], 'manual'), ] # The name of an image file (relative to this directory) to place at # the top of the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings # are parts, not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output ------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'rtmidi', u'python-rtmidi Documentation', [setupcfg['metadata']['author']], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ---------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'rtmidi', u'python-rtmidi Documentation', setupcfg['metadata']['author'], setupcfg['metadata']['name'], setupcfg['metadata']['description'], 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/contributing.rst0000644000175000001440000000627100000000000017561 0ustar00chrisusers============ Contributing ============ Contributions are welcome, and they are greatly appreciated! Every little bit helps, and credit will always be given. You can contribute in many ways: Types of Contributions ---------------------- Report Bugs ~~~~~~~~~~~ Report bugs at https://github.com/SpotlightKid/python-rtmidi/issues. If you are reporting a bug, please include: * Your operating system name and version. * Any details about your local setup that might be helpful in troubleshooting. * Detailed steps to reproduce the bug. Fix Bugs ~~~~~~~~ Look through the GitHub issues for bugs. Anything tagged with "bug" is open to whoever wants to implement it. Implement Features ~~~~~~~~~~~~~~~~~~ Look through the GitHub issues for features. Anything tagged with "feature" is open to whoever wants to implement it. Write Documentation ~~~~~~~~~~~~~~~~~~~ python-rtmidi could always use more documentation, whether as part of the official python-rtmidi docs, in docstrings, or even on the web in blog posts, articles, and such. Submit Feedback ~~~~~~~~~~~~~~~ The best way to send feedback is to file an issue at https://github.com/SpotlightKid/python-rtmidi/issues. If you are proposing a feature: * Explain in detail how it would work. * Keep the scope as narrow as possible, to make it easier to implement. * Remember that this is a volunteer-driven project, and that contributions are welcome :) Get Started! ------------ Ready to contribute? Here's how to set up `python-rtmidi` for local development. 1. Fork the ``python-rtmidi`` repo on GitHub. 2. Clone your fork locally:: $ git clone --recursive git@github.com:your_name_here/python-rtmidi.git 3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development:: $ mkvirtualenv python-rtmidi $ cd python-rtmidi/ $ pip install -r requirements-dev.txt $ python setup.py develop 4. Create a branch for local development:: $ git checkout -b name-of-your-bugfix-or-feature Now you can make your changes locally. 5. When you're done making changes, check that your changes pass flake8 and the tests, including testing other Python versions with tox:: $ make lint $ make test To get flake8 and tox, just ``pip install`` them into your virtualenv. 6. Commit your changes and push your branch to GitHub:: $ git add . $ git commit -m "Detailed description of your changes." $ git push -u origin name-of-your-bugfix-or-feature 7. Submit a pull request through the GitHub website. Pull Request Guidelines ----------------------- Before you submit a pull request, check that it meets these guidelines: 1. The pull request should include tests. 2. If the pull request adds functionality, the docs should be updated. Put your new functionality into a function with a docstring, and add the feature to the release notes in ``CHANGELOG.rst``. 3. The pull request should work for all supported Python 3 versions (see classifiers in ``setup.cfg``) Run ``tox`` to make sure that the tests pass for all supported Python versions. Tips ---- To run a subset of tests:: $ py.test -v tests/test_foo.py::test_foo ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/history.rst0000644000175000001440000000003600000000000016544 0ustar00chrisusers.. include:: ../CHANGELOG.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/index.rst0000644000175000001440000000076000000000000016156 0ustar00chrisusers.. complexity documentation master file, created by sphinx-quickstart on Tue Jul 9 22:26:36 2013. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. .. include:: ../README.rst Contents ======== .. toctree:: :maxdepth: 1 installation install-windows usage modules contributing authors history license Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/install-windows.rst0000644000175000001440000000004400000000000020200 0ustar00chrisusers.. include:: ../INSTALL-windows.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/installation.rst0000644000175000001440000000003400000000000017542 0ustar00chrisusers.. include:: ../INSTALL.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/license.rst0000644000175000001440000000003400000000000016463 0ustar00chrisusers.. include:: ../LICENSE.txt ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/make.bat0000644000175000001440000001450300000000000015722 0ustar00chrisusers@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\complexity.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\complexity.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) :end ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611761526.0 python-rtmidi-1.4.7/docs/modules.rst0000644000175000001440000000006700000000000016517 0ustar00chrisusersrtmidi ====== .. toctree:: :maxdepth: 4 rtmidi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611761526.0 python-rtmidi-1.4.7/docs/rtmidi.rst0000644000175000001440000000247100000000000016340 0ustar00chrisusersrtmidi package ============== Submodules ---------- rtmidi.midiconstants module --------------------------- .. automodule:: rtmidi.midiconstants :members: :undoc-members: :show-inheritance: rtmidi.midiutil module ---------------------- .. automodule:: rtmidi.midiutil :members: :undoc-members: :show-inheritance: rtmidi.version module --------------------- .. automodule:: rtmidi.version :members: :undoc-members: :show-inheritance: Module contents --------------- .. automodule:: rtmidi :members: :undoc-members: :show-inheritance: Functions ~~~~~~~~~ .. autofunction:: get_api_name .. autofunction:: get_api_display_name .. autofunction:: get_compiled_api .. autofunction:: get_compiled_api_by_name .. autofunction:: get_rtmidi_version Exceptions ~~~~~~~~~~ .. autoclass:: rtmidi.RtMidiError :members: .. autoclass:: rtmidi.InvalidPortError :members: .. autoclass:: rtmidi.InvalidUseError :members: .. autoclass:: rtmidi.MemoryAllocationError :members: .. autoclass:: rtmidi.NoDevicesError :members: .. autoclass:: rtmidi.SystemError :members: .. autoclass:: rtmidi.UnsupportedOperationError :members: Classes ~~~~~~~ .. autoclass:: rtmidi.MidiIn :members: :inherited-members: .. autoclass:: rtmidi.MidiOut :members: :inherited-members: ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/docs/usage.rst0000644000175000001440000000215100000000000016147 0ustar00chrisusers======== Usage ======== Here's a quick example of how to use **python-rtmidi** to open the first available MIDI output port and send a middle C note on MIDI channel 1: .. code-block:: python import time import rtmidi midiout = rtmidi.MidiOut() available_ports = midiout.get_ports() if available_ports: midiout.open_port(0) else: midiout.open_virtual_port("My virtual output") with midiout: # channel 1, middle C, velocity 112 note_on = [0x90, 60, 112] note_off = [0x80, 60, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout .. note:: On Windows it may be necessary to insert a small delay after the last message is sent and before the output port is closed, otherwise the message may be lost. More usage examples can be found in the examples_ and tests_ directories of the source repository. .. _tests: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests .. _examples: https://github.com/SpotlightKid/python-rtmidi/tree/master/examples ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2444174 python-rtmidi-1.4.7/examples/0000755000175000001440000000000000000000000015200 5ustar00chrisusers././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2444174 python-rtmidi-1.4.7/examples/advanced/0000755000175000001440000000000000000000000016745 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/advanced/ccstore.py0000644000175000001440000000322700000000000020765 0ustar00chrisusers#!/usr/bin/env python """Record last seen value of specific Control Change events. The main loop prints out last seen value of specific Control Change events every second. The control change events are received by a MIDI input callback, which gets called on every MIDI event received and runs independently from the main loop. """ import time from rtmidi.midiutil import open_midiinput from rtmidi.midiconstants import ( CONTROL_CHANGE, MODULATION, CHANNEL_VOLUME, EXPRESSION_CONTROLLER, ) CONTROLLERS = (MODULATION, CHANNEL_VOLUME, EXPRESSION_CONTROLLER) class MidiInHandler: def __init__(self, channel=1, controllers=None): self.ch = channel self.ccs = controllers or () self._cur_value = {} def __call__(self, event, *args): event, delta = event status = event[0] & 0xF0 ch = event[0] & 0xF if status == CONTROL_CHANGE and ch == self.ch - 1 and event[1] in self.ccs: self._cur_value[event[1]] = event[2] def get(self, cc, default=None): return self._cur_value.get(cc, default) def main(args): midiin, _ = open_midiinput(args[0] if args else None) # record Modulation, Volume and Expression CC events handler = MidiInHandler(channel=1, controllers=CONTROLLERS) midiin.set_callback(handler) try: with midiin: while True: for cc in CONTROLLERS: print("CC #%i: %s" % (cc, handler.get(cc))) print("--- ") time.sleep(1) except KeyboardInterrupt: pass finally: del midiin if __name__ == '__main__': import sys main(sys.argv[1:]) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/advanced/midiclock.py0000644000175000001440000000420400000000000021255 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # midiclock.py # """Receive MIDI clock and print out current BPM. MIDI clock (status 0xF8) is sent 24 times per quarter note by clock generators. """ import time from collections import deque from rtmidi.midiconstants import (TIMING_CLOCK, SONG_CONTINUE, SONG_START, SONG_STOP) from rtmidi.midiutil import open_midiinput class MIDIClockReceiver: def __init__(self, bpm=None): self.bpm = bpm if bpm is not None else 120.0 self.sync = False self.running = True self._samples = deque() self._last_clock = None def __call__(self, event, data=None): msg, _ = event if msg[0] == TIMING_CLOCK: now = time.time() if self._last_clock is not None: self._samples.append(now - self._last_clock) self._last_clock = now if len(self._samples) > 24: self._samples.popleft() if len(self._samples) >= 2: self.bpm = 2.5 / (sum(self._samples) / len(self._samples)) self.sync = True elif msg[0] in (SONG_CONTINUE, SONG_START): self.running = True print("START/CONTINUE received.") elif msg[0] == SONG_STOP: self.running = False print("STOP received.") def main(args=None): clock = MIDIClockReceiver(float(args[0]) if args else None) try: m_in, port_name = open_midiinput(args[0] if args else None) except (EOFError, KeyboardInterrupt): return 1 m_in.set_callback(clock) # Important: enable reception of MIDI Clock messages (status 0xF8) m_in.ignore_types(timing=False) try: print("Waiting for clock sync...") while True: time.sleep(1) if clock.running: if clock.sync: print("%.2f bpm" % clock.bpm) else: print("%.2f bpm (no sync)" % clock.bpm) except KeyboardInterrupt: pass finally: m_in.close_port() del m_in if __name__ == '__main__': import sys sys.exit(main(sys.argv[1:]) or 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/advanced/midioutwrapper.py0000644000175000001440000002104500000000000022374 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # midioutwrapper.py # """Wrap MidiOut to add convenience methods for sending common MIDI events.""" import binascii from rtmidi.midiconstants import (ALL_NOTES_OFF, ALL_SOUND_OFF, BALANCE, BANK_SELECT_LSB, BANK_SELECT_MSB, BREATH_CONTROLLER, CHANNEL_PRESSURE, CHANNEL_VOLUME, CONTROL_CHANGE, DATA_ENTRY_LSB, DATA_ENTRY_MSB, END_OF_EXCLUSIVE, EXPRESSION_CONTROLLER, FOOT_CONTROLLER, LOCAL_CONTROL, MIDI_TIME_CODE, MODULATION, NOTE_OFF, NOTE_ON, NRPN_LSB, NRPN_MSB, PAN, PITCH_BEND, POLY_PRESSURE, PROGRAM_CHANGE, RESET_ALL_CONTROLLERS, RPN_LSB, RPN_MSB, SONG_POSITION_POINTER, SONG_SELECT, TIMING_CLOCK) from rtmidi.midiutil import open_midioutput def parse_sysex_string(s): """Convert a sysex message string in hexadecimal notation into bytes. Example: >>> parse_sysex_string("F0 7E 00 09 01 F7") b'\xf0~\x00\t\x01\xf7' """ return binascii.unhexlify(s.replace(' ', '')) class MidiOutWrapper: def __init__(self, midi, ch=1): self.channel = ch self._midi = midi def send_channel_message(self, status, data1=None, data2=None, ch=None): """Send a MIDI channel mode message.""" msg = [(status & 0xF0) | ((ch if ch else self.channel) - 1 & 0xF)] if data1 is not None: msg.append(data1 & 0x7F) if data2 is not None: msg.append(data2 & 0x7F) self._midi.send_message(msg) def send_system_common_message(self, status=END_OF_EXCLUSIVE, data1=None, data2=None): """Send a MIDI system common message.""" msg = [status & 0xF7] if msg[0] in (MIDI_TIME_CODE, SONG_POSITION_POINTER, SONG_SELECT): msg.append(data1 & 0x7F) if msg[0] == SONG_POSITION_POINTER: msg.append(data2 & 0x7F) self._midi.send_message(msg) def send_system_realtime_message(self, status=TIMING_CLOCK): """Send a MIDI system real-time message.""" self._midi.send_message([status & 0xF7], delta=1) def send_system_exclusive(self, value=""): """Send a MIDI system exclusive (SysEx) message.""" msg = parse_sysex_string(value) if (msg and msg.startswith(b'\xF0') and msg.endswith(b'\xF7') and all((val <= 0x7F for val in msg[1:-1]))): self._midi.send_message(msg) else: raise ValueError("Invalid sysex string: %s", msg) def send_note_off(self, note=60, velocity=0, ch=None): """Send a 'Note Off' message.""" self.send_channel_message(NOTE_OFF, note, velocity, ch=ch) def send_note_on(self, note=60, velocity=127, ch=None): """Send a 'Note On' message.""" self.send_channel_message(NOTE_ON, note, velocity, ch=ch) def send_poly_pressure(self, note=60, value=0, ch=None): """Send a 'Polyphonic Pressure' (Aftertouch) message.""" self.send_channel_message(POLY_PRESSURE, note, value, ch=ch) def send_control_change(self, cc=0, value=0, ch=None): """Send a 'Control Change' message.""" self.send_channel_message(CONTROL_CHANGE, cc, value, ch=ch) def send_program_change(self, program=0, ch=None): """Send a 'Program Change' message.""" self.send_channel_message(PROGRAM_CHANGE, program, ch=ch) def send_channel_pressure(self, value=0, ch=None): """Send a 'Monophonic Pressure' (Channel Pressure) message.""" self.send_channel_message(CHANNEL_PRESSURE, value, ch=ch) def send_pitch_bend(self, value=8192, ch=None): """Send a 'Pitch Bend' message.""" self.send_channel_message(PITCH_BEND, value & 0x7f, (value >> 7) & 0x7f, ch=ch) def send_bank_select(self, bank=None, msb=None, lsb=None, ch=None): """Send 'Bank Select' MSB and/or LSB 'Control Change' messages.""" if bank is not None: msb = (bank >> 7) & 0x7F lsb = bank & 0x7F if msb is not None: self.send_control_change(BANK_SELECT_MSB, msb, ch=ch) if lsb is not None: self.send_control_change(BANK_SELECT_LSB, lsb, ch=ch) def send_modulation(self, value=0, ch=None): """Send a 'Modulation' (CC #1) 'Control Change' message.""" self.send_control_change(MODULATION, value, ch=ch) def send_breath_controller(self, value=0, ch=None): """Send a 'Breath Controller' (CC #3) 'Control Change' message.""" self.send_control_change(BREATH_CONTROLLER, value, ch=ch) def send_foot_controller(self, value=0, ch=None): """Send a 'Foot Controller' (CC #4) 'Control Change' message.""" self.send_control_change(FOOT_CONTROLLER, value, ch=ch) def send_channel_volume(self, value=127, ch=None): """Send a 'Volume' (CC #7) 'Control Change' message.""" self.send_control_change(CHANNEL_VOLUME, value, ch=ch) def send_balance(self, value=63, ch=None): """Send a 'Balance' (CC #8) 'Control Change' message.""" self.send_control_change(BALANCE, value, ch=ch) def send_pan(self, value=63, ch=None): """Send a 'Pan' (CC #10) 'Control Change' message.""" self.send_control_change(PAN, value, ch=ch) def send_expression(self, value=127, ch=None): """Send a 'Expression' (CC #11) 'Control Change' message.""" self.send_control_change(EXPRESSION_CONTROLLER, value, ch=ch) def send_all_sound_off(self, ch=None): """Send a 'All Sound Off' (CC #120) 'Control Change' message.""" self.send_control_change(ALL_SOUND_OFF, 0, ch=ch) def send_reset_all_controllers(self, ch=None): """Send a 'All Sound Off' (CC #121) 'Control Change' message.""" self.send_control_change(RESET_ALL_CONTROLLERS, 0, ch=ch) def send_local_control(self, value=1, ch=None): """Send a 'Local Control On/Off' (CC #122) 'Control Change' message.""" self.send_control_change(LOCAL_CONTROL, 127 if bool(value) else 0, ch=ch) def send_all_notes_off(self, ch=None): """Send a 'All Notes Off' (CC #123) 'Control Change' message.""" self.send_control_change(ALL_NOTES_OFF, 0, ch=ch) def send_rpn(self, param=0, value=0, ch=None): """Send a Registered Parameter Number (RPN) Change via a series of CC messages.""" if isinstance(param, int): param_msb = (param >> 7) param_lsb = param else: param_msb, param_lsb = param if param_msb is not None: self.send_control_change(RPN_MSB, param_msb, ch=ch) if param_lsb is not None: self.send_control_change(RPN_LSB, param_lsb, ch=ch) if isinstance(value, int): value_msb = (value >> 7) value_lsb = value else: value_msb, value_lsb = value if value_msb is not None: self.send_control_change(DATA_ENTRY_MSB, value_msb, ch=ch) if value_lsb is not None: self.send_control_change(DATA_ENTRY_LSB, value_lsb, ch=ch) def send_nrpn(self, param=0, value=0, ch=None): """Send a Non-Registered Parameter Number (NRPN) Change via a series of CC messages.""" if isinstance(param, int): param_msb = (param >> 7) param_lsb = param else: param_msb, param_lsb = param if param_msb is not None: self.send_control_change(NRPN_MSB, param_msb, ch=ch) if param_lsb is not None: self.send_control_change(NRPN_LSB, param_lsb, ch=ch) if isinstance(value, int): value_msb = (value >> 7) value_lsb = value else: value_msb, value_lsb = value if value_msb is not None: self.send_control_change(DATA_ENTRY_MSB, value_msb, ch=ch) if value_lsb is not None: self.send_control_change(DATA_ENTRY_LSB, value_lsb, ch=ch) # add more convenience methods for other common MIDI events here... if __name__ == '__main__': import time mout, name = open_midioutput(interactive=True) try: with mout: mw = MidiOutWrapper(mout, ch=3) input("Press key to send test messsage to port '%s'..." % name) mw.send_program_change(40) mw.send_note_on(60) time.sleep(1) mw.send_note_off(60) time.sleep(0.1) except (EOFError, KeyboardInterrupt): print('') del mout ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/advanced/recvrpn.py0000644000175000001440000000503100000000000020775 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # recrpn.py # """Receive and decode RPN messages. RPN (registered parameter number) messages are just regular Control Change messages with a special semantic. To change an RPN value, the sender first sends the parameter number with CC #100 (LSB) and #101 (MSB) and then the parameter value with CC #38 (LSB) and #6 (MSB). Both the parameter number and value are 14-bit values (MSB * 128 + LSB). See also: http://www.somascape.org/midi/tech/spec.html#rpns """ import time from collections import defaultdict from rtmidi.midiconstants import (CONTROL_CHANGE, DATA_DECREMENT, DATA_ENTRY_LSB, DATA_ENTRY_MSB, DATA_INCREMENT, RPN_LSB, RPN_MSB) from rtmidi.midiutil import open_midiinput class RPNDecoder: def __init__(self, channel=1): self.channel = (channel - 1) & 0xF self.rpn = 0 self.values = defaultdict(int) self.last_changed = None def __call__(self, event, data=None): msg, deltatime = event # event type = upper four bits of first byte if msg[0] == (CONTROL_CHANGE | self.channel): cc, value = msg[1], msg[2] if cc == RPN_LSB: self.rpn = (self.rpn >> 7) * 128 + value elif cc == RPN_MSB: self.rpn = value * 128 + (self.rpn & 0x7F) elif cc == DATA_INCREMENT: self.set_rpn(self.rpn, min(2 ** 14, self.values[self.rpn] + 1)) elif cc == DATA_DECREMENT: self.set_rpn(self.rpn, max(0, self.values[self.rpn] - 1)) elif cc == DATA_ENTRY_LSB: self.set_rpn(self.rpn, (self.values[self.rpn] >> 7) * 128 + value) elif cc == DATA_ENTRY_MSB: self.set_rpn(self.rpn, value * 128 + (self.values[self.rpn] & 0x7F)) def set_rpn(self, rpn, value): self.values[rpn] = value self.last_changed = rpn def main(args=None): decoder = RPNDecoder() m_in, port_name = open_midiinput(args[0] if args else None) m_in.set_callback(decoder) try: while True: rpn = decoder.last_changed if rpn: print("RPN %i: %i" % (rpn, decoder.values[rpn])) decoder.last_changed = None time.sleep(0.1) except KeyboardInterrupt: pass finally: m_in.close_port() del m_in if __name__ == '__main__': import sys sys.exit(main(sys.argv[1:]) or 0) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2454176 python-rtmidi-1.4.7/examples/basic/0000755000175000001440000000000000000000000016261 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/contextmanager.py0000644000175000001440000000104100000000000021646 0ustar00chrisusers#!/usr/bin/env python # # contextmanager.py # """Shows how to use a MidiOut instance as a context manager.""" import time import rtmidi from rtmidi.midiconstants import NOTE_OFF, NOTE_ON NOTE = 60 # middle C midiout = rtmidi.MidiOut() with (midiout.open_port(0) if midiout.get_ports() else midiout.open_virtual_port("My virtual output")): note_on = [NOTE_ON, NOTE, 112] note_off = [NOTE_OFF, NOTE, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/midiin_callback.py0000755000175000001440000000251700000000000021730 0ustar00chrisusers#!/usr/bin/env python # # midiin_callback.py # """Show how to receive MIDI input by setting a callback function.""" from __future__ import print_function import logging import sys import time from rtmidi.midiutil import open_midiinput log = logging.getLogger('midiin_callback') logging.basicConfig(level=logging.DEBUG) class MidiInputHandler(object): def __init__(self, port): self.port = port self._wallclock = time.time() def __call__(self, event, data=None): message, deltatime = event self._wallclock += deltatime print("[%s] @%0.6f %r" % (self.port, self._wallclock, message)) # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. port = sys.argv[1] if len(sys.argv) > 1 else None try: midiin, port_name = open_midiinput(port) except (EOFError, KeyboardInterrupt): sys.exit() print("Attaching MIDI input callback handler.") midiin.set_callback(MidiInputHandler(port_name)) print("Entering main loop. Press Control-C to exit.") try: # Just wait for keyboard interrupt, # everything else is handled via the input callback. while True: time.sleep(1) except KeyboardInterrupt: print('') finally: print("Exit.") midiin.close_port() del midiin ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/midiin_poll.py0000755000175000001440000000203200000000000021132 0ustar00chrisusers#!/usr/bin/env python # # midiin_poll.py # """Show how to receive MIDI input by polling an input port.""" from __future__ import print_function import logging import sys import time from rtmidi.midiutil import open_midiinput log = logging.getLogger('midiin_poll') logging.basicConfig(level=logging.DEBUG) # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. port = sys.argv[1] if len(sys.argv) > 1 else None try: midiin, port_name = open_midiinput(port) except (EOFError, KeyboardInterrupt): sys.exit() print("Entering main loop. Press Control-C to exit.") try: timer = time.time() while True: msg = midiin.get_message() if msg: message, deltatime = msg timer += deltatime print("[%s] @%0.6f %r" % (port_name, timer, message)) time.sleep(0.01) except KeyboardInterrupt: print('') finally: print("Exit.") midiin.close_port() del midiin ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/midiout.py0000755000175000001440000000173700000000000020320 0ustar00chrisusers#!/usr/bin/env python # # midiout.py # """Show how to open an output port and send MIDI events.""" from __future__ import print_function import logging import sys import time from rtmidi.midiutil import open_midioutput from rtmidi.midiconstants import NOTE_OFF, NOTE_ON log = logging.getLogger('midiout') logging.basicConfig(level=logging.DEBUG) # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. port = sys.argv[1] if len(sys.argv) > 1 else None try: midiout, port_name = open_midioutput(port) except (EOFError, KeyboardInterrupt): sys.exit() note_on = [NOTE_ON, 60, 112] # channel 1, middle C, velocity 112 note_off = [NOTE_OFF, 60, 0] with midiout: print("Sending NoteOn event.") midiout.send_message(note_on) time.sleep(1) print("Sending NoteOff event.") midiout.send_message(note_off) time.sleep(0.1) del midiout print("Exit.") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/noteon2osc.py0000644000175000001440000000176400000000000020734 0ustar00chrisusers#!/usr/bin/env python # # noteon2osc.py # """Send an OSC message when a MIDI Note On message is received.""" import sys import time import liblo from rtmidi.midiconstants import NOTE_ON from rtmidi.midiutil import open_midiinput def midiin_callback(event, data=None): message, deltatime = event if message[0] & 0xF0 == NOTE_ON: status, note, velocity = message channel = (status & 0xF) + 1 liblo.send( ('localhost', 9001), '/midi/%i/noteon' % channel, note, velocity) try: # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. port = sys.argv[1] if len(sys.argv) > 1 else None with open_midiinput(port, client_name='noteon2osc')[0] as midiin: midiin.set_callback(midiin_callback) while True: time.sleep(1) except (EOFError, KeyboardInterrupt): print("Bye.") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/panic.py0000644000175000001440000000135100000000000017725 0ustar00chrisusers#!/usr/bin/env python # # panic.py # """Send AllSoundOff and ResetAllControllers on all JACK MIDI outputs and all channels.""" from __future__ import print_function import time import rtmidi from rtmidi.midiconstants import (ALL_SOUND_OFF, CONTROL_CHANGE, RESET_ALL_CONTROLLERS) midiout = rtmidi.MidiOut(rtapi=rtmidi.API_UNIX_JACK) print(__doc__) for portnum, portname in enumerate(midiout.get_ports()): print("Port:", portname) with midiout.open_port(portnum): for channel in range(16): midiout.send_message([CONTROL_CHANGE, ALL_SOUND_OFF, 0]) midiout.send_message([CONTROL_CHANGE, RESET_ALL_CONTROLLERS, 0]) time.sleep(0.05) time.sleep(0.1) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/basic/probe_ports.py0000755000175000001440000000304300000000000021174 0ustar00chrisusers#!/usr/bin/env python # # probe_ports.py # """Shows how to probe for available MIDI input and output ports.""" from rtmidi import (API_LINUX_ALSA, API_MACOSX_CORE, API_RTMIDI_DUMMY, API_UNIX_JACK, API_WINDOWS_MM, MidiIn, MidiOut, get_compiled_api) try: input = raw_input except NameError: # Python 3 StandardError = Exception apis = { API_MACOSX_CORE: "macOS (OS X) CoreMIDI", API_LINUX_ALSA: "Linux ALSA", API_UNIX_JACK: "Jack Client", API_WINDOWS_MM: "Windows MultiMedia", API_RTMIDI_DUMMY: "RtMidi Dummy" } available_apis = get_compiled_api() for api, api_name in sorted(apis.items()): if api in available_apis: try: reply = input("Probe ports using the %s API? (Y/n) " % api_name) if reply.strip().lower() not in ['', 'y', 'yes']: continue except (KeyboardInterrupt, EOFError): print('') break for name, class_ in (("input", MidiIn), ("output", MidiOut)): try: midi = class_(api) ports = midi.get_ports() except StandardError as exc: print("Could not probe MIDI %s ports: %s" % (name, exc)) continue if not ports: print("No MIDI %s ports found." % name) else: print("Available MIDI %s ports:\n" % name) for port, name in enumerate(ports): print("[%i] %s" % (port, name)) print('') del midi ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2474174 python-rtmidi-1.4.7/examples/drumseq/0000755000175000001440000000000000000000000016660 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/README.rst0000644000175000001440000000422300000000000020350 0ustar00chrisusersDrum Pattern Sequencer ====================== This example was contributed by Michiel Overtoom [1]_. I just embellished it a bit and added command line option handling. You can see Michiel's original script in the repository history. The script ``drumseq.py`` implements a simple drum pattern sequencer, which reads patterns from text files in a very simple and easy to edit format, and plays them back as a MIDI note sequence to a given MIDI output. Each line starts with the MIDI note number of a drum sound and is followed a sequence of characters indicating at which step this drum should be triggered. Different characters map to different velocities and a ``.`` signifies velocity zero, i.e. the drum note will not be triggered at this step. A dash ``-`` is a tie, neither a note off nor a new note is sent at this step. Each line must have the same number of steps. One step is nominally a 1/16 note, but you are free to define a pattern with twelve steps and increase the BPM by a factor of 4/3 to get a triplet-feel. Lines starting with a hash (``#``) are ignored and can be used for comments or temporarily muting a drum sound. The third field of each line, after the pattern sequence, should name or describe the drum sound to use, but you are free to put there whatever you want, the field is not used by the sequencer. You can change the MIDI port, channel, bank and program via command line options and also specify the BPM at which the pattern is played back. For a mapping of midi notes to General MIDI drum sounds, see http://en.wikipedia.org/wiki/General_MIDI#Percussion For a General MIDI compatible software synthesizer, see: macOS (OS X) SimpleSynth_ Linux Qsynth_ (GUI) or fluidsynth_ (command line) Windows Builtin The patterns whose filenames start with ``example_`` are taken from the article *The Rhythm Method. Effective Drum Programming* published by the Sound on Sound magazine [2]_. .. [1] http://www.michielovertoom.com/ .. [2] http://www.soundonsound.com/sos/feb98/articles/rythm.html .. _simplesynth: http://notahat.com/simplesynth/ .. _qsynth: http://qsynth.sourceforge.net/ .. _fluidsynth: http://sourceforge.net/apps/trac/fluidsynth/ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/break-on-through.txt0000644000175000001440000000042300000000000022574 0ustar00chrisusers# Break On Through # 188 bpm # 1...|...|...|...2...|...|...|... 36 x.......x.......x.......x.....s. Bassdrum 37 m.....m.....m.......m.....m..... Rimshot 44 ....m.......m.......m.......m... Pedal Hi-hat 59 s-s+s-s-s-s-s-s-s-s+s-s-s-s-s-s- Ride 2 (try "Ride 1" (51) as well!) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/drumseq.py0000755000175000001440000001452500000000000020724 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # drumseq.py # # MIDI Drum sequencer prototype, by Michiel Overtoom, motoom@xs4all.nl # """Play drum pattern from file to MIDI out.""" from __future__ import print_function import argparse import sys import threading from random import gauss from time import sleep, time as timenow import rtmidi from rtmidi.midiutil import open_midioutput from rtmidi.midiconstants import (ALL_SOUND_OFF, BANK_SELECT_LSB, BANK_SELECT_MSB, CHANNEL_VOLUME, CONTROL_CHANGE, NOTE_ON, PROGRAM_CHANGE) FUNKYDRUMMER = """ # 1...|...|...|... 36 x.x.......x..x.. Bassdrum 38 ....x..m.m.mx..m Snare 42 xxxxx.x.xxxxx.xx Closed Hi-hat 46 .....x.x.....x.. Open Hi-hat """ class Sequencer(threading.Thread): """MIDI output and scheduling thread.""" def __init__(self, midiout, pattern, bpm, channel=9, volume=127): super(Sequencer, self).__init__() self.midiout = midiout self.bpm = max(20, min(bpm, 400)) self.interval = 15. / self.bpm self.pattern = pattern self.channel = channel self.volume = volume self.start() def run(self): self.done = False self.callcount = 0 self.activate_drumkit(self.pattern.kit) cc = CONTROL_CHANGE | self.channel self.midiout.send_message([cc, CHANNEL_VOLUME, self.volume & 0x7F]) # give MIDI instrument some time to activate drumkit sleep(0.3) self.started = timenow() while not self.done: self.worker() self.callcount += 1 # Compensate for drift: # calculate the time when the worker should be called again. nexttime = self.started + self.callcount * self.interval timetowait = max(0, nexttime - timenow()) if timetowait: sleep(timetowait) else: print("Oops!") self.midiout.send_message([cc, ALL_SOUND_OFF, 0]) def worker(self): """Variable time worker function. i.e., output notes, emtpy queues, etc. """ self.pattern.playstep(self.midiout, self.channel) def activate_drumkit(self, kit): if isinstance(kit, (list, tuple)): msb, lsb, pc = kit elif kit is not None: msb = lsb = None pc = kit cc = CONTROL_CHANGE | self.channel if msb is not None: self.midiout.send_message([cc, BANK_SELECT_MSB, msb & 0x7F]) if lsb is not None: self.midiout.send_message([cc, BANK_SELECT_LSB, lsb & 0x7F]) if kit is not None and pc is not None: self.midiout.send_message([PROGRAM_CHANGE | self.channel, pc & 0x7F]) class Drumpattern(object): """Container and iterator for a multi-track step sequence.""" velocities = { "-": None, # continue note ".": 0, # off "+": 10, # ghost "s": 60, # soft "m": 100, # medium "x": 120, # hard } def __init__(self, pattern, kit=0, humanize=0): self.instruments = [] self.kit = kit self.humanize = humanize pattern = (line.strip() for line in pattern.splitlines()) pattern = (line for line in pattern if line and line[0] != '#') for line in pattern: parts = line.split(" ", 2) if len(parts) == 3: patch, strokes, description = parts patch = int(patch) self.instruments.append((patch, strokes)) self.steps = len(strokes) self.step = 0 self._notes = {} def reset(self): self.step = 0 def playstep(self, midiout, channel=9): for note, strokes in self.instruments: char = strokes[self.step] velocity = self.velocities.get(char) if velocity is not None: if self._notes.get(note): midiout.send_message([NOTE_ON | channel, note, 0]) self._notes[note] = 0 if velocity > 0: if self.humanize: velocity += int(round(gauss(0, velocity * self.humanize))) midiout.send_message([NOTE_ON | channel, note, max(1, velocity)]) self._notes[note] = velocity self.step += 1 if self.step >= self.steps: self.step = 0 def main(args=None): ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) aadd = ap.add_argument aadd('-b', '--bpm', type=float, default=100, help="Beats per minute (BPM) (default: %(default)s)") aadd('-c', '--channel', type=int, default=10, metavar='CH', help="MIDI channel (default: %(default)s)") aadd('-p', '--port', help="MIDI output port number (default: ask)") aadd('-k', '--kit', type=int, metavar='KIT', help="Drum kit MIDI program number (default: none)") aadd('--bank-msb', type=int, metavar='MSB', help="MIDI bank select MSB (CC#00) number (default: none)") aadd('--bank-lsb', type=int, metavar='MSB', help="MIDI bank select LSB (CC#32) number (default: none)") aadd('-H', '--humanize', type=float, default=0.0, metavar='VAL', help="Random velocity variation (float, default: 0, try ~0.03)") aadd('pattern', nargs='?', type=argparse.FileType(), help="Drum pattern file (default: use built-in pattern)") args = ap.parse_args(args) if args.pattern: pattern = args.pattern.read() else: pattern = FUNKYDRUMMER kit = (args.bank_msb, args.bank_lsb, args.kit) pattern = Drumpattern(pattern, kit=kit, humanize=args.humanize) try: midiout, port_name = open_midioutput( args.port, api=rtmidi.API_UNIX_JACK, client_name="drumseq", port_name="MIDI Out") except (EOFError, KeyboardInterrupt): return seq = Sequencer(midiout, pattern, args.bpm, args.channel - 1) print("Playing drum loop at %.1f BPM, press Control-C to quit." % seq.bpm) try: while True: sleep(1) except KeyboardInterrupt: print('') finally: seq.done = True # And kill it. seq.join() midiout.close_port() del midiout print("Done") if __name__ == "__main__": sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_01.txt0000644000175000001440000000045700000000000021362 0ustar00chrisusers# Example Groove 1 # 100-120 bpm # |...|...|...|...|...|...|...|... 46 ..............................x- Open Hi-hat 44 ....x.......x.......x.......x... Pedal Hi-hat 42 x.s.x.s.x.s.x.s.x.s.x.s.x.s.x... Closed Hi-hat 38 ....x.......x.......x.......x... Snare 36 x.......x.....s.x.......x....... Bassdrum ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_02.txt0000644000175000001440000000045700000000000021363 0ustar00chrisusers# Example Groove 2 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 x.....s.x.......x.....m.x....... Bassdrum 38 ....x.......x.......x.......x... Snare 42 x.s.x.s.x.s.x.s.x.s.x...x.s.x.s. Closed Hi-hat 44 ....x.......x.......x.......x... Pedal Hi-hat 46 ......................x-........ Open Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_03.txt0000644000175000001440000000037700000000000021365 0ustar00chrisusers# Example Groove 3 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 x.......x.....m.x.......x.....s. Bassdrum 38 ....x.......x.......x.......x... Snare 42 x...s...x...x...x...s...x...s... Closed Hi-hat 44 ..m...s...m...ss..m...s...m...s. Pedal Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_04.txt0000644000175000001440000000031600000000000021357 0ustar00chrisusers# Example Groove 4 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 x.......x.....s.x.......x.....m. Bassdrum 38 ....x.......x.......x.......x... Snare 42 xssx.xssssxs.xssxssx.xssssxs.xss Closed Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_05.txt0000644000175000001440000000044600000000000021364 0ustar00chrisusers# Example Groove 5 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 x.......x.s...s.x.......x.....m. Bassdrum 38 ....x.......x.......x.......x... Snare 42 x.xm.xm.xmxmxmxxxm.xm.xm.xx.xmxm Closed Hi-hat 51 x...x..s.x..x...x...x...m.sm.x.. Ride 54 ..m...s...m...s...m...s...m...s. Tambourine ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_06.txt0000644000175000001440000000045700000000000021367 0ustar00chrisusers# Example Groove 6 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 x.s.....x.m.....x.........x..... Bassdrum 38 ....x.......x.......x.......x... Snare 42 x...m..xm...x...x...m...x...s... Closed Hi-hat 44 .....s...s...m.s.....s...s...... Pedal Hi-hat 46 ..x-..m...x-..m...x-..m-..x-..m- Open Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_07.txt0000644000175000001440000000045600000000000021367 0ustar00chrisusers# Example Groove 7 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 xs.m....x.x....m..x...x..m.s.... Bassdrum 38 ....x.......x.......x.......x.mm Snare 42 xx..x.s.x.sx..s.x.s.x.s.x.s.x.s. Closed Hi-hat 44 x.x.xx..x...x..x..x.x..x..x.x.x. Pedal Hi-hat 54 msxsmsxsmsxsmsxsmsxsmsxsxsmsxsms Tambourine ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_08.txt0000644000175000001440000000045600000000000021370 0ustar00chrisusers# Example Groove 8 # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 xs....m...xm...mx.x...x..m.s.... Bassdrum 38 ....x....x..x.s.....x.......xmmm Snare 42 xx..x.s.x.sx..s.x.s.x.s.x.s.x.s. Closed Hi-hat 44 x.x.xx..x...x.x.....x..x..x.x.x. Pedal Hi-hat 54 msxsmsxsmsxsmsxsmsxsmsxsxsmsxsms Tambourine ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_09.txt0000644000175000001440000000066200000000000021370 0ustar00chrisusers# Example Groove 9 # 110-130 bpm (for a real tempo of 82.5-97.5 bpm) # 1.....|.....|.....|.....2.....|.....|.....|..... 36 x.s..m......x..x.......m...x.....x....m..s...... Bassdrum 38 ......x-..........x-..........x-..........x-.m-m Snare 42 x.x...x..s..x..s.x...s..x..s..x..s..x..s..x..s.. Closed Hi-hat 44 x..x..x.x...x.....x....x...x..x....x...x..x..x.. Pedal Hi-hat 54 m-sx-sm-sx-sm-sx-sm-sx-sm-sx-sm-sx-sx-sm-sx-sm-s Tambourine ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_10.txt0000644000175000001440000000066300000000000021361 0ustar00chrisusers# Example Groove 10 # 110-130 bpm (for a real tempo of 82.5-97.5 bpm) # 1.....|.....|.....|.....2.....|.....|.....|..... 36 x.s......m.....x.m.....mx..x.....x....m..s...... Bassdrum 38 ......x--.....x-..x--s-.......x--.........x-mm-m Snare 42 x.x...x..s..x..s.x...s..x..s..x..s..x..s..x..s.. Closed Hi-hat 44 x..x..x.x...x.....x....x......x....x...x..x..x.. Pedal Hi-hat 54 m-sx-sm-sx-sm-sx-sm-sx-sm-sx-sm-sx-sx-sm-sx-sm-s Tambourine ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_11.txt0000644000175000001440000000045300000000000021357 0ustar00chrisusers# Example Groove 11 # 90-110 bpm # 1...|...|...|...2...|...|...|... 36 x..m....x..x..smx.m....sx.x..... Bassdrum 38 .............m........s......m.. Snare 1 40 ....m....m.sx.......m....s..m... Snare 2 46 ..m-............m-.............. Open Hi-hat 44 mx..m.m.m.s.sms...msm.m.s.mss.sm Pedal Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/example_12.txt0000644000175000001440000000053300000000000021357 0ustar00chrisusers# Example Groove 12 # 90-110 bpm # 1...|...|...|...2...|...|...|... 36 x...............x.........x..... Bassdrum 37 x.....m.m...m.......m..x....x... Rimshot 38 ........x.....x.........x....... Snare 42 x.m.x.m...m.x.m.x.m.x.m...m.x.m. Closed Hi-hat 44 x...x.......x.......x........... Pedal Hi-hat 46 ........x-..............x-...... Open Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/funkydrummer.txt0000644000175000001440000000023500000000000022151 0ustar00chrisusers# Funky Drummer # 1...|...|...|... 36 x.x.......x..x.. Bassdrum 38 ....x..m.m.mx..m Snare 42 xxxxx.x.xxxxx.xx Closed Hi-hat 46 .....x.x.....x.. Open Hi-hat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/rosanna-shuffle.txt0000644000175000001440000000031500000000000022513 0ustar00chrisusers# Rosanna Shuffle # about 124 bpm (for a real tempo of 93 bpm) # 1..|..|..|..2..|..|..|.. 36 x....m...x.....m..s..... Bassdrum 40 .+-.+-m+-.+-.+-.+-m+-.++ Snare 2 42 x-sx-sx-sx-sx-sx-sx-sx-s Closed Hi-hat././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/drumseq/template.txt0000644000175000001440000000073500000000000021241 0ustar00chrisusers# Pattern Template # 100-120 bpm # 1...|...|...|...2...|...|...|... 36 ................................ Bassdrum 37 ................................ Rimshot 38 ................................ Snare 42 ................................ Closed Hi-hat 44 ................................ Pedal Hi-hat 46 ................................ Open Hi-hat 49 ................................ Crash 51 ................................ Ride 54 ................................ Tambourine ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2484176 python-rtmidi-1.4.7/examples/midi2command/0000755000175000001440000000000000000000000017543 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midi2command/000-playback.mp30000644000175000001440000013162600000000000022260 0ustar00chrisusersInfom  #%'*,.1368=?ADFHKMORTY[]`bdgilnpuwz|~9LAME3.99r$B Cq^K;1M4hъ** ʈ2x2+XP$('"V!X`qU;jJޫh:I淚R4Xf\LեP#"E!l[$֫J&33rW~^EkgMM1~ysw9"*wsrQkb-w^c1.޳stSa[uʤ@"I&UT-7c0VNeLH Mga݌j>V 8BVKMsje*uܶ|v[X{վJaʶ)*hTҁyBPe/#QqI) V,2QWwTʛZ߬;^3=6dYJW2"Fcg;m{2G\X53wwYewW/T@#[U*U'!\b/~(-JFsIB0k(((6R#3-P)Y qm `1-Q`k}f`"T@eȵu|H ]bUvyUet3if_B&>U1nA*US'h]ƞZ6.;kzѯ+ٖ DPA!.0L(Ag( ,8m/K(a/ e nCAN@IJ%m0yYxIL ao! 6ShLA,"fSoE "RtAf1; ,SM.{S?J"z< t[LnYZ󮢢-T9չR=g"q91<-^8Dp!r3ƓG}+_Zac/XQvТq? c JѠ3TA2ҽ,hg"=d8P g,'H;0A,;f99A"5*]Z H8, T;%d2}Eu7ڏ`=:JAwWպL 4.I@*Ih"89 4(bؽ @oK/'nU4uO#K 81c4.=<f> ӟ@V3*R_SXYENzMBM>"֙f!*%NYt t:RQi ?QԢ DJL. &pP$9wĂf6Qa Z?h4@%C #P`N0P0t B3:cT8jʂRe19P a )aܓ1680Ds6 ȭlo=&܊o]V KC @I 25ݷP"VSBr1DÍ&`pP"H&#ITL0 )"L& 2clM\2dd n x|itš8d4h|kʒr$ ȉB.""TXЖ(Dҡxm՞;dXsçpP.ϡ@h7u0!0P5%4& @nLAS2Ctw0pgBb4`3toÞa00`X,hd$ ( h! ))ˡ9Q"ЍI@\)@A444G@ty{Z!nl1L`.Q}kÑa@j[D2hT^,6)AFx $O4 ˥TmUD`Y6b6 QRM0.%I|&@\d sVw$ wNy@CX #CDŽ % C. ڂ$$p0s4`Gb@= uT$ FւKf:DhoQ`q;(P/!`PHb`* \͛_ IASTd0U }A!P2G T c^DE!c!`9jRˈdSv! QG;,(8#eJT1Ve# 1L,7Y *}"ҼA|' ?B4P(@_ "BE-d}*yHbd0p)x.rej ٕИ<Jqg78BS5@\pʉɂHP5 g\PgضWNvmeb]P~oj*&v )dyYp4m>`PP$z(%q,a : P8, 3م)۠ىY&Yq ZƑ "2i8aģ _2F  wcIءRrEP"V0bx`>4>@PK`axLcixINc84``~br`HJH:6);\@0Xрƌë]L !&T^v Eb ]6 }v ՚э4\qgrURlhGӘ,rn\W{'8-)"Qm9@0 11w2<2 N'  V Pad㔁APq' J &?hr1qr8ueMYWe0xI4+(22 x ;Y% [V+u?u_.# P9$X`3" b* TQC%@`"q(l`PZ,8c@`0d0{rCCiEDz'}>ƐF CQ Y EPYUFk fTxc}ց\'WgiT17aA `,r4`Lfid*wk ͩ DAnBc띘#"``8"cjr~aPXd)Boc`pA4 P 8졌KX \`FOdr@60K|0@4e ʁ ^48*1eoFv`Xqh@L`abzaLeG#'\ЂV ^ے#c BSacL x "8! `MT2HirC0cq32GD7IC clMWm;  26ЀQ@boDlPa8CN2".B @`q*pa Fgel}A, c uqK#0Qsm*SPHG@h4a`/# y%2؆  6, SdNnHwrE%vZ]vWd&U\-LkvCj q%x2aa$X!0_4ق8=)2'`owk9>=a BM¬@2d*L_WTV1l{#&^X |P2X@[XU2Ѐ;SÞWl)OڔGyRW&{#!pye3w b4"08cU0t` n[9A 21qqڂ1bPabo̡|~<4(X.“A~RU0DJ5#ä!09/%ꨁ%F9ѳ7Vt7-o[N{~_~9uWS1 i6au-L04*@H^a9hLP-?AH0ԋ*]&jG37`Ti@ T}5샙!OtM c.,]֢ }.|D&kAy-jF9hZ[Q1ߖњz\, LA]OP@ 3B\:\|H ղT$8$ }@à N@ԭ0`j&&R jf,bHf\JH0W L0REP4D1 =qD!CLJ5(dAUP4@9v;PQu)9A!  i`61$T rX LP FSɑ+q¡L>rB$%g042K=uK@ 402T3o0 (01Dd81lsҀ.BJ4 nb KuaXŜ}?;n_sӘ룞cU#cN,\ƹX{ReSf+s 8XS @0st03x17P130oTs }#PK1@D1(р탙6 OuK?My2,8CͅxxI8)AP.ՎtLke">IV2a*{CSCѴvc" P}@yLseC \s(h!,0p6,s p&0s0@G0@:icΒ1Q )@Q"& ,bcӶ` [Z0(zU]:&)nUUa,,62}oo]Z׶L7՛^o55.eTN"Vcr3A*P;u0#;6.ac @I`R2i`Fda` yBpʪ&Rއ&E' OhT>My׫F.#aK(DxTq-3g@UGK \Tv&Sw߿͙39Vfcyƚ6<x#<)DŽ"p,3" .0E0N1142MR^|gdlS HAHh2bL!AJ!@造e` o LsqG3Պ[o} 콩U!lSiV*C@`>F`fcnI,e1&0w3+0 S( ھ mh y 7ܮ˿PkA6o[,*Lǃ mZEƵ$Hp7^IIlpj`€=Fӄ LaC P`: !!Pq"cpqhhb(rb5saXWI@( c탘~ ohT."qqh6B a<0`w @@Ñ#e?d@FI~ O쌽_}ףDm=9XfSu@1D ;P ` 7F`0倖0lPc01v }1IXASiI@0EC f[ dX 6z$.= PI5 p%  i'j_*hoZ"Jg#Z)QT R:0X . q!cãDFP:((t0h! s< >Ҙ( \9O0`̿ @LW)pܮPBσ: otKA9EfUP߼U 7qУ )~>ߦO7٧͠({0bǸarqDQpQ0"0&qb`$ aoҡ`fL%d0+`ޓ*`:pe>'@YH43SA[q PU BçԀ@<t8aw@0Q Č˥P@ `p3+ȔO.ld'+.֣ 1,P|$b{AF SaTp0 |&[0cB1:CY0[@e0} #>Pb0v0 0C`:0> S1?r t Abb\ q3h  T @2 jm`p*\Mϕ5_ڳuڍM3]\9cm/RFћ2KהI1F.L@'T!L|P (LʗI Qq )3yy щ@1I1ɆtÈC sC5D& J@!>Džȑ =4nou~=[ޟW2&qR!1\C̒NX!PT-LX0 ƁH@( n< L402Dap° `2 ޶v  ;AxA8 Ռ $!DmC2yP)}a`]'[̭߯ blSFÄXM PXij xPMЊ(6* 0)U@HS312=}3Z0c $2~0P+0- c@1ZS  i@A2Bj>taa+ q܄q@X$0Icehd*J@5>.n'v6oMsT,|Z)ޖFo*"4Ū$K9G 8< ;a⢡B.m1P '"<;JTjE&h 5-aޞP'T95LYdimC\"M  I:v# `a&`H D4`QT P#Mۧݿ˫bw3.s8.e!E"$a 8!4,<œ>N`m%Ʌ0IO@LDBXAh۟t .3V.@blpF`bTn4`28 rÄ| i|5M,0h~M?ڛ2eTr*&;8DI0XDiH &"!&$"1xSP8 0610 3=1$1&00J@] c`4Gf2t byspC2@@(:F$X9PP^lݨ Gv_M??џv?uo{OD1x'^XgvV!dEBv~,Byōv$Ca3]#JzD2h8A88k̤!#!aaLbJBbD>!04; P0 020320))4p0* Re tԆ 9>_@u;\_^?|$&"J9L4ʸ_I޴]&H[5F (Ӫ$1 h&!Du@}' (Odt0L vL Lk"@I\ fJ  ;.A pFG H15 0C8 P !`Իm5^yVrєs̮J+Y\ΥGƣQiOv4hAI1d00QnH.yQS* XqRA`F m:ZCe13Z0sB c"[,FLAME3.99.5UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU1(PB0t'80r O9;A81 #5PC0r3@t<?0= &1`:0!8s"0!!01$`<njid`LQ @$,hNH pYH<T]Mߒ1AVO_mnȆ%Tv9c͗ O|[/*]Y۫-v?rt>ŀH( @I@X<4L (L(ȹW1 S0@dYģ $\LT@ QĈ`.#p SЕ@>w5uaO'}Z6r6bЪ0ux$s>Ͱwa*a& ,,#F ׺a0(M&Q`=d ]L) 鋚aXш 4ޖ K 8 9\1IUE`뿦޺*}2229^#8(@em&DHHIͮBQ6uVafI̜xԁkIh K)H)$9XK}8O )0|aPC,J0TD_fv_CP1+sX@ND3LXwS K_6-{zӵWD e*PsHeۃML'9cmGIQD$A[rEB1Q+ @0`90azv0P ̲x QŒ4 X@# Ҁ _D9A8A`4Tk#§1z`h Ӱ8lz4ѻh'o|їN9OBdmM(P8p<"vvUIb#$4ʓ2e LA0PhL! a,F(b&Ie$F .s001CIBC@ 8rs|88 J4`$LQTKZ./B/^_տ֞6kQ*3qbʂVI&Z E`H4´u͉b]1% Ѩ4a:(lqP'ًPiG P[PV8L4L ]!y =j  9A8% y8w@PA:h }dk^_|Ϯ~ko7(CQ ISt9V.BohI0O4$C$@WH8wLD W t8 ƒ4Ŕ,8mpzp`` φ`,& `L2 nj`TF!ȐDd!}G ƽO7?uZu|?Tslwz3B =[6emO IvUM!*gZU` > )p1\Q-x/ 񌸍XQyH05Yz|@8 s@X 9':`pd, $*%(cz(o };{Z9]k-ͣ_^WN|+BVMl4*"902DN} r'UՁbA dXi@ 7 L!BL=L"LLQL)Lx  x0H 8& P `@ b `*H"6/UFF'R+с0hW32#gpNJh) R020brF01 1\-p=08::s01>0 0+Є0?"  9 '840f!=2 @L%uσ/ٯRڳh?Y=On*:E f3in @`B A@Fv ^Hf B.$aIX1 L9!(HbqzBb)P?р@X `Mˬ,cI`*24| F4oZ UXDK۳;tK*)$ED`،QK9"5`DjYTְpaC6 M1J-1 0%C{ ڽk>dյ:WS,]{_Vt 1B%.gk+|2.! `<036.YIPI)` I[H8P̈L8dLǮ؊ 9a1 10q09" ҷ9qߠC~k2zJ|Fve1iA:*-'6A,FIz(6fJ#&<L @h¨0NݎPL|YGLœ$10TULBLLL 4 4laNI($axl* %2 g E"  z/ʺ/{(Cjv{g?3Y=Q]TdGoZCk^Uz69+dee됕G-շu0`50azG0ƎbfS<` F$"Nt)'`F5ha ^`(XA`BlZ 9CAA0d\-TWڣg7?)S;3O4YYk_u?B5U_T 0)x$$S.([0Pg%̟e ,mY1mz1s0H0320<pr0A1: s a3E#@gLI !@@hLGd\bT #8F9׉o.5-tVinȪj9΍eg+(D:R }T͞{ӜX^[Cj4UY4\l0 џØ, M`! i lC LF˼ L4 )b 98fa FR@6]U__751н6hDEieF(QAh4XRLnm[2BeTAb!Wi^(i2dCy!(:`,~qF``F-!e /a)Za*@cV@2&g`@+~* [/g.2Lfc_Am{Y2BpZufw'72eEjjwI#X` tXh<,)Z]<\18m7USU@ fu\&#8`*>dHR19S1Qc1Fa0!}3sY0&C 2c0  9#A1,c @p$Vg= Қ^ۖU[N[FLTYU@CwPNh|v\aS52n1.\w%ث$&b#o5L h\L<LdœLKL(8$@H.Ŋ, 6c @6DÀ@k )@Yh(F+yo??͖\.Mi_A~jweVQ@ gH.d&BE-(-N)gY=de1S080tsf00ey(' W1JF8J $&cڝ%Pj / Aa1 IYs p(ّa9@Y@I1gjȈY& 9!t@~b @Dp`UBbJ5.۽6lf!%4.>~53SP'ޢV W&x3+Q6/B ɡrby.\ _ d 78 JbFOf0dvyb`g^b DCä@iyDf1jw?v_EEꫳo_&yYaNYƘ#`ӐT9!]]R9^3mpڥ:[a,s? Qu 08&p% σELaܘ1Hwad xZZIFabhE !VH@mO}WFʴgw2ڏ7[rwQRشWΓEHSH\HcMRBW!&@D 8.[B戈Y 88X ޝ}-!LL aNcƐl xl`f`F*Aat`e@'.0;,X[ݾ]67-0eiS}rE[-ٯ9}-\e}_Fx~͜GM.]c̮i}IwH$BS0C3nw`y0 c #1C# 0?DC0xP՜  Ly,D` 0Is]0 "A+Sg? GKr2gRQgwMZqlHbDir"pIBj#i1 `W#HF(r5]]]!-0P;0#8ga0L ?@!$釠 =ٓH8 D  F".sX /A1z*|$+^od^-iz%c*y_OӣPv: kxj7.FOw}\F e%~ur"B`hpu:oMIy\Wt PٌA(ä .hФ$itP@8jLqT ¸M`$ L_7o" ?>fdf2a*q5_O[)F&nOj^.R]XDӖ.xZ"UchԬXJ@bvbkF0@:01v0O~0;@Q8'I@zH|ɠ PL,ĕX /$AaA1d! I!4\ȿU5$az}Z׷3,[(enq s*D B 4Pe(n:2URB |4J!yr4(` a((BNhLID(ʠ 4° XL¤ PB&d&lAl46 @YCc__e*g}:ο{ufg{v1W]e}ml{r1INe](h#Rq=J}wIJY5LψEʌ(aJ!T0\"%c@g0A3`0y:8#`V0}0P% AP, @5rlx(V 9 AA2 ='G~PCK, ̼TgiKOѝ,rssv4\.EJeCbr.oyexBhlY U!q{oP (( Nj L$LfA& .@D!, Eb``-q+@x#3+iHyV "ЎԝͲTVt,DC$1]Lߥ}4IkkK+&Y`/T-D0 9WD[nab^U05aX R9rO( &0c%0Sk0{ pcF\¬Ԍ ʃtaR ap Z  +2 pH~h,pa&z~jvyblw{*v%n-̲lLj:8\nsb'(hMʈ&\lhmqP+XP@hQLPLA0ˆ LAHàL) и f.dad0Cp'88+)P; 0 Zdmhdi?b:fPGR3]֨Dvo5ˆzSyg^p^#H'd&#Q$I!I &dL$@7090190Ba 0х .I*ه5Y 0ag8/>d:  7 AA&fA `B _=+EgO6n)sHf܇o}[6i=urݻ-Yu8LۨEԅSˡDtȨqD9e+i0GHӱ>ID@2NpxxQ w'WsADP+)9 ˆ7&GPՉifUfiIɵ!]K$; =_~g> ٜ]tV#%>'k]z E28^<`&J_(-H%a, Yz"p2?`Xٍɛd.D ĴL l0 )Cfْ AA~xR"lCߢH㹐]a@6(?q<:gfz-3=kZ\]0(FGܔ*Z~tVŃq}*׎JO3x܊:@LD=l M& 0ˆÂ8eL=@$ cnaf @4 iFX gPF}g8,&Y/2ޟ);e3]LsduUF2w>^㔾yIT9QeҖmzjV$jj hP #L}`AAf4+!K@)s3G_j0s00RSc~001#p;( 6ax0!0T `2*0.Q̄AJ $&("Ƶ*"g~_#I?V34kdkMSI D(I ʒ% XP6|E4O@РtI#DD0  [PA8jѐ#gQI5 #h  L,j&a",2+a̐9 DMH~miWIVWϙ~aѝ!2u☱o>$:#2OR` xihboDզ؆B`GTUL LG`L1GDL3d8a0R<0 PYk Bׂ 7#Aa*IC܇+ޞsܞd>>Tro{~Lm3ԭmWch jPz%rÅJZ j ÊԸ>>IRv!8, AUAoLOE` 6$0Mˆ 8T ` ( LȴfA$*@T[vm]MݕTUͥt;MȭyW|}݉JYr-K2|ZVK ʆ5bI]! Fe8R#8\ @,0qSҶ3?0-m 3 7 @ \ p!T4TYo 72DŽHs!AOF2l"S3/ꦝjdřu[kzXvp݈IJnhxI P[+OZ+zS@x8 B$a0# _8Jaa0?1)3 z00H0}#C1  x0lP fh& /:rg?ByX%*ov*Ьwffڋf{-ݸi^DyӼ6ڌ8vޮ)K&tX$GIeFS$S""i xku0c#0S#j0`s 9qܛfQ&4"a  a_n".2,h`aņ_IWNW[>O^۵ܞ컵_ݵn,6#P!SA9_܅q4냉3,vJN JBL;*,A Az*&9+Gɟa15yvNFHQ6 W4@aLaO@*( -9/U{- FB>1::Jt$kA @+JXqi3q r xH@Zd` A@ :5wޞj?{c)`sJuRwOvroL)z|bԻ#_G,z%E7V L?=ZB,׏0ؒpjLS' &PP0!O\,\m͐Ldżn,T4:bF C I;D0B DA2yD+/+kĩ*q fld!~OTZ[Rbknf،yw7 p䂡RL:uՏR.)TFcj4aX0spV7 00 K0 G0)D0`k1z  K0#E,S $PY#Ϣ #dwo32 j#3,no.vi;9jZ&Lv dᄆ6}*ILLCԔ#6;V-9TVcNjdGB0S00P cD@0S0!;S @.VP(NaD $| T0z aIk}N:jyjD%#CF :{2y~gs72J̤PLn{*Pc[T:+ KZX˫9CFk-?,qKe~8D?jh1 fgn̦ ` Edav]%aB Fc&7B1)0HM"Qjsk/?OYTv)MG,mQd2TZն/umm`rؚ"Zcod:P9-)G$3'⧋)LpǐImBq9'EaU!GAy}080$07 r0e8 0D q6! P ܘVw L @ L& z ]Β_E +B 2;*3*?d(uyՔA*fE5UhRk=~_iCzȣisJ9& -i#e}CH$*VOX&pK\C?u Q|( ᪒V;oQ Gل9%0 h@f@bf $^n ,t0Hvj ?_ș,qIFa+l‡:?/)2k5kˍȵ.{˅D+,9D hhKSҕ̎Vlan CJ lv%"0[orz s+0$3Q c5~69ذKX $ \  AKO#nCaڦTdUgfwuS=fvfo9jkP}><}_:DњRYG)[+mo46mi!ьCsE%e띝;ࡥp' PԘ1ǘwH8RQ)SB@! )ȡ( r|( Ԏ9s#>m#HL8fsD0 dtdH n.ۿ2V]Fx&;i[SBφi͞* B Y˅A)E b00E C\0\ X@eRƘ$L(d X2!P0Ҩ1.DD $ 2> *z1̌a%19/?x %xqq&`nF=Cdm(θ[^{ua#F%O+Vei yB'Wa`1AW1*) faTb!` c @bP} ⷃ6c_JHR*NCB :"Y3k'L[Y٫q3 ~ѕRBgMkЯZR"̼S|04P|K fp>O} (!Ҧ  8 N`2Cfa `RbT-& &``31Y F R>0 b@7t8 f*2efssT:T1`ɮ$3k\՛?tk[K/;?ḳf DcəBEȎT0eӡo2M5tqq005OC0, L1 p>0&#HC0 HU ŀ0 *D€,r4 VdkW4c*GfeE!Lc@,KQ𮈴ZPQ' "$˪(0 .a]X4-IC sbH\dQ),D 4`OD7$n +B 2\w"$z= OC2RB+%J_~w-o N"ڵ4puI] t飢ᒄEAy\$pSsԀ}'hhg`]H\_ LTJL)@P` dL#@L Vzs"EN"$9ECxxh!i+I L0(DqɅ3ET~`˜N`2"lj`vP 0#C00 >4c$s<020`0Œ >%x(jK:fG+5ȎCUbŚTVv"UM6^3gYyNs:$%jYB~6y`pUՓ2~9T,Nx6t/BP B4E20rٍjـ@. `:#(4HdL-@ P Unf {3JM?b?ؚ32TSb$) l!9byˀͣl_5}1bqWe7YyW&IڱZXQ^5<~W`'.Ywx.dz lDLuLt!C,S:"p +J\($Xk4 @tĤ="xa꘠ @\* ud(uFD"UwC-̙PbQ5N{5~/-0ԾUJgf L`ؾ@ Q-1>R? Oh˩Ĥx3fx XAD`B(P, V``f` dh@```F`.ɀ $(X0Pk bH.HVB5~Ui;~i;^{m"j,٢4>1FKʋI!fZx-8~rk}-@$O|X Т~0C0Q ciT+0 c (ÄyMSGL8Й @asr"!ilA-w A2׿#9HA Aq5"L3M%W%r|TךUwN1/;Cާr k$It/a;V/ԙEt|P+ӊ3 TXG !}' !A#FYp8p~s0V$1PJ,54֮MBc)2;2*,cc8l j̶=?cnq۫uŌlzWoVc ӶNS | =Dž:jO咿9FT,*Cجp<!`bpT#0`0D>!0^C!0!X{P_CpBHn_ڲ  B 7{_vES0$Vum[n3!4RN.g49- 垆A+ JBFD@!8>CYP ij+8ɁYLap S  1@7zH(h's5OwUg #3wZ9b8Cȟz֎?󓶷C:|nϚ}}Cp4P/q.Z24 #֍6ďX+Eb;%&LĒ4 actPZO -V(P$a;HL&ǤGLg(Ł4\/ā`4 ~YlD@8 772}kseb7u] Le#*|䩳sԝe^Ю~Ϝj-=ag\arYeb \!B;bi 'e %aTrÞ#`0Qf09i@%>i`  È[HC80hLjP VlvfG5md9N +=6Կzfk{f:{Nq`ھW(WW-n[#9 0NCvSL2Tr Hb{Qe] X!)D` (Q0тP 3 `A 0]Ya@"+P A>^3-.j&F>9Z2\̏e)_yO3U]n&ul2Ƞ:9FKWQFp46! s[{f+N^ej*ږ~ 9w!v*aeS5GOZtu%bJgtx5aQ K"Y p| `(ݷj(@09OR; ` 4CWHb`0A\` iya 23(C;"9.u#l4`?pO,o󓳷3KzVW9eʕ/6 4'|..!B!?D#u#Ci\8=#8)0\_C2F NmDB`J`& a8Ɖz`fa/f *!x`d*.(bgro۴b323"HBgƣw$#"2jg=мctիXqx M ߯CpYhĞz+ҩ#b)vG7e!|l-W6w: \j**p>  90L!< Fez`f.pb``.0BCXh;Ѩ$uTdIPYWKB >oEs̖uu\VKfܵ Eѿ}}/M:ik4~Ͷ %f}: Fi"T 2mV^fVF"GJ$J.uP!Ln0a P0 .d.0<300n3Aq3c--q9@ +^ej :D9G^ZyaٕPffHَ?&ֶ4֚urx)stиל=Y|0 ^DS <@5H\zd}ڀU$ {0b(ɥL('P``EƠ`~b #c2y=#n[pЬ667"{l=f8*鄝k{;EJĢ\P ݞHkP.u3(+&jJN 9%~r ңΥ 4` @_g8pb8 [zfίEuKPcDFr1lGMGF~߽{m̹|huCǧ )WMCv5KFo+Q1x;n9BJYҕrYQHI@.&\`D0&@T0Fs3C#S AY09W !'=*#ڞ o >ndNʒ-JS^gcZtEBFYϩIz֔w,Ԥxke;48:W<5gƓpR²I EZ?%h|ĊQ:C|90Ǒ܌"pL"/2]n5 1 91g?Aj10l*1r0"Z$ذBPqgYF9|jRDWcKD cYÝR:]ʽt!OopR%I`=d^<#گzϠ+G5 *Sls1=%[^Qc8F2q>g(.*+ p 髙2^n)D"B[!]LK9Ulu1C gl^)=j ":ym浧єvS̴[DbTu3tRb!R\M35!&z~Өj5s۪ @™L!`+"pM q˜!h@ p`-03jTr[2 .>onϼAՙTGB2r9j(S2dUMgy1I ^ .tG]7.89fFDc^B].Kzx4 !KqȖFSNު~o[2 |6c5<0(BW(   bR]e@N&kT+J΁,GFPlH&;%8wusLS?}\~fy[6iOcHQdOqbAYa$v6^vaItV% :Њ+@`6&ј#8`AH@`B-&U`ra8aXB(1an[2 A2WҎfu; ܃#;I;t9m,˓}V~˚j`mS[rxO T E1$Jlj2Ј,gw` 0CT,\  XLϨN\\"l԰ 6hq:*;_}6ΫdGM0`DSskD'_S}p=-t,XF{$HOC?`kgV-K&"2|t,,tdڈIsJ1|"Nho* Kˠ^1WK .K,a|3b f;L BHL"b 񨲝Qg=Z  Y A>3:f:"!њ+ 0y-ԮrSvu|!9E81(qJ0mX'96VbaHTlxċ2@m%( fGjcDix aHc$z*b Jq$]״IoK#v:QDc dSfVE)_jWJofΫM5>/j]5BJ1cTaQ\z6.b,B ]VnP7qxE.GJR~BcW}*0P$`d @2`R1fW#0`v`)f $Á{=bHkJ[G*e;T 7! >hB%`fTQe0&bdVR{om<}_ekx56X)cB,rTH6iƟʞUhQClo(Ψ(D!5PӜec,:N-yPB0O]x?:F&. + 1!H1xJHIފUO iwJz+u %єrb#KR"/2z_1/hQH ]h_=ZWjKgSJU id-iڻ)P_ove+Vّ փ|PMiiVؾH: l` 09*o`h)FH$  S4MAf CjA $$tq B >ۙMcj(KVKYT.jj#w\vغ>PWoq癈eSSU'%7Plh~xO+? 52, AH~>pYG@`B ,* dhPp 6`V ae` `f`r@ 6귃׼YJ%_F1{dF9*$o5 ɵ[WlP&h*P3 aj7DiS,v*ۚ OU+*X1>Ukj$ttdṰoj00&'@D& Ʊ !u ?ÛK_cv/;-  A>tPv+&ykԙd쿢+5g:aڽ)keSbF{T.etiG[ӍGz-BЇ9/\)DjDC $RH0`<31+0D2 04T1H#1>@1hFVă_ "IZNۯu}K#JCJ9C Ff8H*b*ýiofFc2^#oJ-egz%2Fķ . i GE}]! nP1TG3HA_ͤ9Fým QBp`0%}0(#P0Z3 Ch#a[F@ n_٪Wn6AA>5uRU)dPٌU`NʮrJ4ʕ* K浇Y˽2t[ۙ(=ے *rԫ}fUB H>ctxkdAe^Jj % F=|)6.Ť@#HGF08=ʀ=.UKJFCqB$!UaJQ%:0qM`Q*E{RKUgֵMf@&fxFrsqT=ٚ^S߯y(:vd[ǭD&,| ]4ÞPP`:mjD`[aᑡ 'a|__  %e1 d} $z(9K[<SرOظd~%V>BQ8tJZ?*V:Y^)VO: 3cAc#01,4 , %< [wZ#P:bTDv#PuoR3,vؗTF;ʾjdx_S-tI}bSa@EEUI,?>Mز4eB ‖P/2,O4 zaO! EL<`0U?L>C@ܰP<){5ӷwt3  >AԬtBB5є4[:A Ur)}j/kq=g mC͙yPfqP^XBU,hJΔRBMuDX D)#M˹ܲppF(Np >4~f+) 3JJ*yoE_tTtd=be:D0$)kb!4[lObof|2F%~[aEyc2DtZ|2i:C2% pcRlkI#\Iж)\hsiCbha3Sj6Z Pl/ q 8P1@ˆ|uȁ`$8L!Yز*AA>{3ڽxE`ְR:6-؞ ut}мG{u{Zxq,X^qHI+"} FOQ%)Z+9+ &5R|GS't&"Ƒ\,vX A)d(\:L@`p`*Ch`YPk.`BFPerf`A  {qhA;03\ȿWS"*;51YI81Y]U׻~\]ұm<]>{VzG|F2Y+zng) sM D5z܇9- jdSZڋ У>ھ8tb :T]BPHVI(9QJ*#usUz2Hۚzg_hLF(7]ez)nU%|G*nU!-Ywi.apJETZz*,NMi Q#.ACsƻ#s@ @tTb :c{Xb.`dl<;DHX5i:=Rẇ:UBG*VQ-GrʇMY3Ei퇺- X/s20@e{u#!*|Q7"vF4KvG/j7'2o3C[@`t,h NJ2BAɊ0)1t@e ` \tr !klm{:r#:2>ewct2D;-+5du9RX2ѱV+ySǙYYu jT)*,8WJRp-̾_v!h 0L:,0%0(1&3 01T;1,CC ꈔET8i!wj۩I3XXE3! (} pG\39t|;EhwxkSe?Kv^"#Jt莾zҭ<\31I+Q q8 r;#o*]" A*B48L  %f1"`&0! dj~%< 6.AA>v>W"hʪe2 A) ġ\^Y5k+i\"xSާo|ᗌzN^jo{28ʇ'YȲl-*Q >:@i9@ɂ@ é`@]rÄ@ۤɽn2NknV1ɫ2^Vӽ溯{Q)Pj q.`p[wJxJ櫝lFP9q292!a k4x_LbjDP+s;A CZs61P(.Wd c S?> A>eZèATs=G<>j+|g&ff,Tz>\w. ?T+Q&% mJ+%SHN+No˱Z r`$0°Q130D1;#g"Ÿ_G~ُ[n"Z3vPa)qpwQvA(CwEd=9$:;3,Q*xP]QY\SI.7mycԔ#&l^Vu[r b4Dad.Ha̕=&X %E .6V'&NsZZE`QsEa@) G`F@#pHCUNR/}I)zȨ$I+WtusIV"3%s,'-o%X 1*Tb[dZ|; bEjvN FYNg3\ІŁF*D)VxsHg&&+Pa}b$ R|a($@Y  yT2քk?خA>V S)tfتj7T͢:d*wC'9ϑsB:P/Vt41NF#$r'J&Lgŀky#-X+T04Pc,HQ,&p@52(mؖ- Aa5쌨0ʀY1DCn6ۯOff OZh梞g#qqoH^/:\%@u\CE #21(ØBSY^OcBs2d 4VQ"lD.) X0`A"?Ϊֳ* )ՐE̢Et3DDp#+> &$0 c)Hֿ3bS;u_3јrhnQtDsjmQ܁I,E ?#M6buVΛLwcB9PG`%C\j!|peL+S!;OvfŽ{GZpBLW5%)fT>:E^` #X 7 SH4aQ'X#JI}t 2K4a0-LL\KL%IIClb,A"eU- kb9]cUWnB A>$A)| UBHTF-6bFCY%YKud%yw9>˜hcʄ73!V*Ɍ")cTz z)M%WK "tBJb%*>Ǡ6+H* Y02Tbpc 5MF qx_CKy5,ϗz̲!nEI洊V饙paeJ1bQ#)HTm&HiCG  (+X,+e`,(@+0X_RPBd,"|J X&&'oZf;UF4fUp6,8 @b|@(ő@txH٨跠IV$>G .vg"0ED/ "Հ.4UfF[@WKE3u[nK8MPqz5Hgn=N.YNOd,-ǪCJ3:\sq|¸[CZT*f7%ҹigpV/ZYSJVfn,MqX(Z{#{fe+ťkS#NJX3KGLJ 7kBYܽ.LJ#a''a__pLIM(U%vtu;nر??:BO6LAME3.99.5UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU2 :+[CpgJڑqCd),u⑹@|ϊ%RI4,T> endobj % 'F1': class PDFType1Font 2 0 obj % Font Helvetica << /BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font >> endobj % 'F2': class PDFType1Font 3 0 obj % Font Helvetica-Bold << /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font >> endobj % 'Page1': class PDFPage 4 0 obj % Page dictionary << /Contents 8 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 7 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans << >> /Type /Page >> endobj % 'R5': class PDFCatalog 5 0 obj % Document Root << /Outlines 9 0 R /PageLabels 10 0 R /PageMode /UseNone /Pages 7 0 R /Type /Catalog >> endobj % 'R6': class PDFInfo 6 0 obj << /Author () /CreationDate (D:20140316094828-01'00') /Creator (\(unspecified\)) /Keywords () /Producer (ReportLab PDF Library - www.reportlab.com) /Subject (\(unspecified\)) /Title (This is just a test) >> endobj % 'R7': class PDFPages 7 0 obj % page tree << /Count 1 /Kids [ 4 0 R ] /Type /Pages >> endobj % 'R8': class PDFStream 8 0 obj % page stream << /Length 318 >> stream 1 0 0 1 0 0 cm BT /F1 12 Tf 14.4 TL ET q 1 0 0 1 62.69291 741.0236 cm q 0 0 0 rg BT 1 0 0 1 0 4 Tm /F2 20 Tf 24 TL 153.8049 0 Td (This is just a test) Tj T* -153.8049 0 Td ET Q Q q 1 0 0 1 62.69291 719.0236 cm q BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (Nothing to see here) Tj (\205) Tj T* ET Q Q endstream endobj % 'R9': class PDFOutlines 9 0 obj << /Count 0 /Type /Outlines >> endobj % 'R10': class PDFPageLabels 10 0 obj % Document Root << /Nums [ 0 11 0 R ] >> endobj % 'R11': class PDFPageLabel 11 0 obj % None << /S /D /St 1 >> endobj xref 0 12 0000000000 65535 f 0000000113 00000 n 0000000221 00000 n 0000000386 00000 n 0000000559 00000 n 0000000836 00000 n 0000000991 00000 n 0000001253 00000 n 0000001358 00000 n 0000001774 00000 n 0000001856 00000 n 0000001949 00000 n trailer << /ID % ReportLab generated PDF document -- digest (http://www.reportlab.com) [(\344u\243;K\323\216{\012\250C\350\327\255Xt) (\344u\243;K\323\216{\012\250C\350\327\255Xt)] /Info 6 0 R /Root 5 0 R /Size 12 >> startxref 1996 %%EOF ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midi2command/README.rst0000644000175000001440000001277000000000000021241 0ustar00chrisusersmidi2command ============ The ``midi2command`` example script shows how you can use ``python-rtmidi`` to receive MIDI messages and execute different external programs and scripts when a MIDI message is received. A configuration file defines which program is called depending on the type and data of the received message. Usage ----- Simply call the ``midi2command.py`` script with the name of a configuration file as the first and sole positional argument, i.e. :: python midi2command.py example.cfg You can optionally specify the MIDI input port on which the script should listen for incoming messages with the ``-p`` option (or the ``--port`` long form). The port may be specified as an integer or a (case-sensitive) substring of the port name. In the latter case either the first matching port is used, or, if no matching port is found, a list of available input ports is printed and the user is prompted to select one. If no port is specified, ``midi2command`` opens a virtual MIDI input port. For systems where several MIDI backend API are available (i.e. ALSA and JACK on Linux or CoreMIDI and JACK on macOS/OS X), you can select the backend to use with the ``-b`` (or ``--backend``) option. The available backends are: * alsa (Linux) * coremidi (macOS/OS X) * jack (Linux, macOS/OS X) * windowsmm (Windows) If you do not specify a backend or one which is not available on the system, the first backend which has any input ports available will be used. Here's the full synopsis of the command:: usage: midi2command.py [-h] [-b {alsa,coremidi,jack,windowsmm}] [-p PORT] [-v] CONFIG Execute external commands when specific MIDI messages are received. positional arguments: CONFIG Configuration file in YAML syntax. optional arguments: -h, --help show this help message and exit -b {alsa,coremidi,jack,windowsmm}, --backend {alsa,coremidi,jack,windowsmm} MIDI backend API (default: OS dependant) -p PORT, --port PORT MIDI input port name or number (default: open virtual input) -v, --verbose verbose output Configuration ------------- The script takes the name of a configuration file in YAML_ syntax as the first and only positional argument. The configuration consist of a list of mappings, where each mapping defines one command. Here is a simple example configuration defining two commands. The description of each command explains what it does:: - name: My Backingtracks description: Play audio file (from current directory) with filename matching -playback.mp3 when program change on channel 16 is received status: programchange channel: 16 command: plaympeg %(data1)03i-playback.mp3 - name: My Lead Sheets description: Open PDF file (from current directory) with filename matching -sheet.pdf when control change 14 on channel 16 is received status: controllerchange channel: 16 data: 14 command: evince %(data2)03i-sheet.pdf The value of the ``status`` key is matched against the status byte of the incoming MIDI message. The ``status`` key is required and may have one of the following values: * noteon * noteoff * programchange * controllerchange * pitchbend * polypressure * channelpressure The value of ``data`` key is matched against the data bytes of the incoming MIDI message. It may be a single integer or a list or tuple with one or two integer items. If ``data`` is not present or empty, the configuration matches against any incoming MIDI message with a matching status byte. If ``data`` is a single integer or a list or tuple with only one item, only the first data byte of the MIDI message must match. The command to execute when a matching MIDI message is received is specified with the value of the ``command`` key. This should be the full command line with all needed options and arguments to the external program. The command line is parsed into tokens by `shlex.split()`_ and then passed to `subprocess.Popen()`_. The command line is not passed to a shell, so it is not supported to prepend environment variable assignments or use any shell variable substitutions or similar. If you need this functionality, just use a wrapper shell or batch script for your external program. The program must be found on your ``PATH`` or you need to specify the absolute or relative path to the executable. The command will be executed in the current working directory, i.e. the one you started ``midi2command`` in. You can put some placeholders into the command string, which will be replaced with values from the MIDI message which triggered the command. The placeholders must adhere to the `Python string formatting`_ syntax and use the dictionary style, e.g. ``%(status)02X`` would be replaced with the value of the MIDI status byte in hexadecimal notation (with upper case letter ciphers) and zero padded to two ciphers. These are the valid placeholder keys, all corresponding values being integers or ``None`` if not present: * status * channel (1-based) * data1 (``None`` if MIDI message has only one byte) * data2 (``None`` if MIDI message has only one or two bytes) .. _yaml: http://www.yaml.org/spec/1.2/spec.html .. _shlex.split(): https://docs.python.org/2/library/shlex.html#shlex.split .. _subprocess.popen(): https://docs.python.org/2/library/subprocess.html#subprocess.Popen .. _python string formatting: https://docs.python.org/2/library/stdtypes.html#string-formatting-operations ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midi2command/example.cfg0000644000175000001440000000101200000000000021651 0ustar00chrisusers# example configuration for the midi2command.py script - name: My Backingtracks description: Play audio file with filename matching -playback.mp3 when program change on channel 16 is received status: programchange channel: 16 command: plaympeg %(data1)03i-playback.mp3 - name: My Lead Sheets description: Open PDF with filename matching -sheet.pdf when control change 14 on channel 16 is received status: controllerchange channel: 16 data: 14 command: evince %(data2)03i-sheet.pdf ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midi2command/midi2command.py0000644000175000001440000001573400000000000022472 0ustar00chrisusers#!/usr/bin/env python # # midi2command.py # """Execute external commands when specific MIDI messages are received. Example configuration (in YAML syntax):: - name: My Backingtracks description: Play audio file with filename matching -playback.mp3 when program change on channel 16 is received status: programchange channel: 16 command: plaympeg %(data1)03i-playback.mp3 - name: My Lead Sheets description: Open PDF with filename matching -sheet.pdf when control change 14 on channel 16 is received status: controllerchange channel: 16 data: 14 command: evince %(data2)03i-sheet.pdf """ import argparse import logging import shlex import subprocess import sys import time from os.path import exists try: from functools import lru_cache except ImportError: # Python < 3.2 try: from backports.functools_lru_cache import lru_cache except ImportError: lru_cache = lambda: lambda func: func import yaml import rtmidi from rtmidi.midiutil import open_midiinput from rtmidi.midiconstants import (CHANNEL_PRESSURE, CONTROLLER_CHANGE, NOTE_ON, NOTE_OFF, PITCH_BEND, POLY_PRESSURE, PROGRAM_CHANGE) log = logging.getLogger('midi2command') BACKEND_MAP = { 'alsa': rtmidi.API_LINUX_ALSA, 'jack': rtmidi.API_UNIX_JACK, 'coremidi': rtmidi.API_MACOSX_CORE, 'windowsmm': rtmidi.API_WINDOWS_MM } STATUS_MAP = { 'noteon': NOTE_ON, 'noteoff': NOTE_OFF, 'programchange': PROGRAM_CHANGE, 'controllerchange': CONTROLLER_CHANGE, 'pitchbend': PITCH_BEND, 'polypressure': POLY_PRESSURE, 'channelpressure': CHANNEL_PRESSURE } class Command(object): def __init__(self, name='', description='', status=0xB0, channel=None, data=None, command=None): self.name = name self.description = description self.status = status self.channel = channel self.command = command if data is None or isinstance(data, int): self.data = data elif hasattr(data, 'split'): self.data = map(int, data.split()) else: raise TypeError("Could not parse 'data' field.") class MidiInputHandler(object): def __init__(self, port, config): self.port = port self._wallclock = time.time() self.commands = dict() self.load_config(config) def __call__(self, event, data=None): event, deltatime = event self._wallclock += deltatime if event[0] < 0xF0: channel = (event[0] & 0xF) + 1 status = event[0] & 0xF0 else: status = event[0] channel = None data1 = data2 = None num_bytes = len(event) if num_bytes >= 2: data1 = event[1] if num_bytes >= 3: data2 = event[2] log.debug("[%s] @%i CH:%2s %02X %s %s", self.port, self._wallclock, channel or '-', status, data1, data2 or '') # Look for matching command definitions cmd = self.lookup_command(status, channel, data1, data2) if cmd: cmdline = cmd.command % dict( channel=channel, data1=data1, data2=data2, status=status) self.do_command(cmdline) @lru_cache() def lookup_command(self, status, channel, data1, data2): for cmd in self.commands.get(status, []): if channel is not None and cmd.channel != channel: continue if (data1 is None and data2 is None) or cmd.data is None: return cmd elif isinstance(cmd.data, int) and cmd.data == data1: return cmd elif (isinstance(cmd.data, (list, tuple)) and cmd.data[0] == data1 and cmd.data[1] == data2): return cmd def do_command(self, cmdline): log.info("Calling external command: %s", cmdline) try: args = shlex.split(cmdline) subprocess.Popen(args) except: # noqa: E722 log.exception("Error calling external command.") def load_config(self, filename): if not exists(filename): raise IOError("Config file not found: %s" % filename) with open(filename) as patch: data = yaml.load(patch) for cmdspec in data: try: if isinstance(cmdspec, dict) and 'command' in cmdspec: cmd = Command(**cmdspec) elif len(cmdspec) >= 2: cmd = Command(*cmdspec) except (TypeError, ValueError) as exc: log.debug(cmdspec) raise IOError("Invalid command specification: %s" % exc) else: status = STATUS_MAP.get(cmd.status.strip().lower()) if status is None: try: int(cmd.status) except: # noqa: E722 log.error("Unknown status '%s'. Ignoring command", cmd.status) log.debug("Config: %s\n%s\n", cmd.name, cmd.description) self.commands.setdefault(status, []).append(cmd) def main(args=None): """Main program function. Parses command line (parsed via ``args`` or from ``sys.argv``), detects and optionally lists MIDI input ports, opens given MIDI input port, and attaches MIDI input handler object. """ parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) padd = parser.add_argument padd('-b', '--backend', choices=sorted(BACKEND_MAP), help='MIDI backend API (default: OS dependent)') padd('-p', '--port', help='MIDI input port name or number (default: open virtual input)') padd('-v', '--verbose', action="store_true", help='verbose output') padd(dest='config', metavar="CONFIG", help='Configuration file in YAML syntax.') args = parser.parse_args(args) logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG if args.verbose else logging.INFO) try: midiin, port_name = open_midiinput( args.port, use_virtual=True, api=BACKEND_MAP.get(args.backend, rtmidi.API_UNSPECIFIED), client_name='midi2command', port_name='MIDI input') except (IOError, ValueError) as exc: return "Could not open MIDI input: %s" % exc except (EOFError, KeyboardInterrupt): return log.debug("Attaching MIDI input callback handler.") midiin.set_callback(MidiInputHandler(port_name, args.config)) log.info("Entering main loop. Press Control-C to exit.") try: # just wait for keyboard interrupt in main thread while True: time.sleep(1) except KeyboardInterrupt: print('') finally: midiin.close_port() del midiin if __name__ == '__main__': sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2484176 python-rtmidi-1.4.7/examples/midifilter/0000755000175000001440000000000000000000000017330 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midifilter/__init__.py0000644000175000001440000000000000000000000021427 0ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midifilter/__main__.py0000644000175000001440000000712300000000000021425 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # midifilter/__main__.py # """Simple MIDI filter / processor.""" from __future__ import absolute_import import argparse import logging import sys import threading import time try: import Queue as queue except ImportError: # Python 3 import queue from rtmidi.midiutil import open_midiport from .filters import MapControllerValue, MonoPressureToCC, Transpose log = logging.getLogger("midifilter") class MidiDispatcher(threading.Thread): def __init__(self, midiin, midiout, *filters): super(MidiDispatcher, self).__init__() self.midiin = midiin self.midiout = midiout self.filters = filters self._wallclock = time.time() self.queue = queue.Queue() def __call__(self, event, data=None): message, deltatime = event self._wallclock += deltatime log.debug("IN: @%0.6f %r", self._wallclock, message) self.queue.put((message, self._wallclock)) def run(self): log.debug("Attaching MIDI input callback handler.") self.midiin.set_callback(self) while True: event = self.queue.get() if event is None: break events = [event] for filter_ in self.filters: events = list(filter_.process(events)) for event in events: log.debug("Out: @%0.6f %r", event[1], event[0]) self.midiout.send_message(event[0]) def stop(self): self.queue.put(None) def main(args=None): parser = argparse.ArgumentParser(prog='midifilter', description=__doc__) padd = parser.add_argument padd('-m', '--mpresstocc', action="store_true", help='Map mono pressure (channel aftertouch) to CC') padd('-r', '--mapccrange', action="store_true", help='Map controller value range to min/max value range') padd('-t', '--transpose', action="store_true", help='Transpose note on/off event note values') padd('-i', '--inport', help='MIDI input port number (default: ask)') padd('-o', '--outport', help='MIDI output port number (default: ask)') padd('-v', '--verbose', action="store_true", help='verbose output') padd('filterargs', nargs="*", type=int, help='MIDI filter argument(s)') args = parser.parse_args(args) logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG if args.verbose else logging.INFO) try: midiin, inport_name = open_midiport(args.inport, "input") midiout, outport_name = open_midiport(args.outport, "output") except IOError as exc: print(exc) return 1 except (EOFError, KeyboardInterrupt): return 0 filters = [] #filters = [CCToBankChange(cc=99, channel=15, msb=0, lsb=1, program=99)] if args.transpose: filters.append(Transpose(transpose=args.filterargs[0])) if args.mpresstocc: filters.append(MonoPressureToCC(cc=args.filterargs[0])) if args.mapccrange: filters.append(MapControllerValue(*args.filterargs)) dispatcher = MidiDispatcher(midiin, midiout, *filters) print("Entering main loop. Press Control-C to exit.") try: dispatcher.start() while True: time.sleep(1) except KeyboardInterrupt: dispatcher.stop() dispatcher.join() print('') finally: print("Exit.") midiin.close_port() midiout.close_port() del midiin del midiout return 0 if __name__ == '__main__': sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/midifilter/filters.py0000644000175000001440000000605700000000000021362 0ustar00chrisusers# -*- coding: utf-8 -*- # # midifilter/filters.py # """Collection of MIDI filter classes.""" from rtmidi.midiconstants import (BANK_SELECT_LSB, BANK_SELECT_MSB, CHANNEL_PRESSURE, CONTROLLER_CHANGE, NOTE_ON, NOTE_OFF, PROGRAM_CHANGE) __all__ = ( 'CCToBankChange', 'MapControllerValue', 'MidiFilter', 'MonoPressureToCC', 'Transpose', ) class MidiFilter(object): """ABC for midi filters.""" event_types = () def __init__(self, *args, **kwargs): self.args = args self.__dict__.update(kwargs) def process(self, events): """Process incoming events. Receives a list of MIDI event tuples (message, timestamp). Must return an iterable of event tuples. """ raise NotImplementedError("Abstract method 'process()'.") def match(self, msg): return msg[0] & 0xF0 in self.event_types class Transpose(MidiFilter): """Transpose note on/off events.""" event_types = (NOTE_ON, NOTE_OFF) def process(self, events): for msg, timestamp in events: if self.match(msg): msg[1] = max(0, min(127, msg[1] + self.transpose)) & 0x7F yield msg, timestamp class MapControllerValue(MidiFilter): """Map controller values to min/max range.""" event_types = (CONTROLLER_CHANGE,) def __init__(self, cc, min_, max_, *args, **kwargs): super(MapControllerValue, self).__init__(*args, **kwargs) self.cc = cc self.min = min_ self.max = max_ def process(self, events): for msg, timestamp in events: # check controller number if self.match(msg) and msg[1] == self.cc: # map controller value msg[2] = int(self._map(msg[2])) yield msg, timestamp def _map(self, value): return value * (self.max - self.min) / 127. + self.min class MonoPressureToCC(MidiFilter): """Change mono pressure events into controller change events.""" event_types = (CHANNEL_PRESSURE,) def process(self, events): for msg, timestamp in events: if self.match(msg): channel = msg[0] & 0xF msg = [CONTROLLER_CHANGE | channel, self.cc, msg[1]] yield msg, timestamp class CCToBankChange(MidiFilter): """Map controller change to a bank select, program change sequence.""" event_types = (CONTROLLER_CHANGE,) def process(self, events): for msg, timestamp in events: channel = msg[0] & 0xF # check controller number & channel if (self.match(msg) and channel == self.channel and msg[1] == self.cc): msb = [CONTROLLER_CHANGE + channel, BANK_SELECT_MSB, self.msb] lsb = [CONTROLLER_CHANGE + channel, BANK_SELECT_LSB, self.lsb] pc = [PROGRAM_CHANGE + channel, self.program] yield msb, timestamp yield lsb, timestamp yield pc, timestamp else: yield msg, timestamp ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sendsysex.py0000755000175000001440000001232000000000000017600 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # sendsysex.py # """Send all MIDI System Exclusive files given on the command line. The paths given on the command line can also include directories and all files with a *.syx extension in them will be sent (in alphabetical order). All consecutive SysEx messages in each file will be sent to the chosen MIDI output, after confirmation (which can be turned off). """ import argparse import logging import os import sys import time from os.path import basename, exists, isdir, join import rtmidi from rtmidi.midiutil import list_output_ports, open_midioutput try: raw_input except NameError: # Python 3 raw_input = input __program__ = 'sendsysex.py' __version__ = '1.1' __author__ = 'Christopher Arndt' __date__ = '$Date$' log = logging.getLogger("sendsysex") SYSTEM_EXCLUSIVE = b'\xF0' END_OF_EXCLUSIVE = b'\xF7' def send_sysex_file(filename, midiout, portname, prompt=True, delay=50): """Send contents of sysex file to given MIDI output. Reads file given by filename and sends all consecutive sysex messages found in it to given midiout after prompt. """ bn = basename(filename) with open(filename, 'rb') as sysex_file: data = sysex_file.read() if data.startswith(SYSTEM_EXCLUSIVE): try: if prompt: yn = raw_input("Send '%s' to %s (y/N)? " % (bn, portname)) except (EOFError, KeyboardInterrupt): print('') raise StopIteration if not prompt or yn.lower() in ('y', 'yes'): sox = 0 i = 0 while sox >= 0: sox = data.find(SYSTEM_EXCLUSIVE, sox) if sox >= 0: eox = data.find(END_OF_EXCLUSIVE, sox) if eox >= 0: sysex_msg = data[sox:eox + 1] # Python 2: convert data into list of integers if isinstance(sysex_msg, str): sysex_msg = [ord(c) for c in sysex_msg] log.info("Sending '%s' message #%03i...", bn, i) midiout.send_message(sysex_msg) time.sleep(0.001 * delay) i += 1 else: break sox = eox + 1 else: log.warning("File '%s' does not start with a sysex message.", bn) def main(args=None): """Main program function. Parses command line (parsed via ``args`` or from ``sys.argv``), detects and optionally lists MIDI output ports, opens given MIDI output port, assembles list of SysEx files and calls ``send_sysex_file`` on each of them. """ ap = argparse.ArgumentParser(description=__doc__) aadd = ap.add_argument aadd(dest='sysexfiles', nargs="*", metavar="SYSEX", help='MIDI system exclusive files or directories to send.') aadd('-l', '--list-ports', action="store_true", help='list available MIDI output ports') aadd('-p', '--port', dest='port', help='MIDI output port number (default: open virtual port)') aadd('-d', '--delay', default="50", metavar="MS", type=int, help='delay between sending each Sysex message in milliseconds ' '(default: %(default)s)') aadd('-y', '--no-prompt', dest='prompt', action="store_false", help='do not ask for confirmation before sending') aadd('-v', '--verbose', action="store_true", help='verbose output') args = ap.parse_args(args) logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG if args.verbose else logging.INFO) if args.list_ports: try: list_output_ports() except rtmidi.RtMidiError as exc: log.error(exc) return 1 return 0 files = [] for path in args.sysexfiles or [os.curdir]: if isdir(path): files.extend(sorted([join(path, fn) for fn in os.listdir(path) if fn.lower().endswith('.syx')])) elif exists(path): files.append(path) else: log.error("File '%s' not found.") if not files: log.error("No SysEx (.syx) files found in given directories or working directory.") return 1 try: midiout, portname = open_midioutput(args.port, interactive=False, use_virtual=True) except rtmidi.InvalidPortError: log.error("Invalid MIDI port number or name.") log.error("Use '-l' option to list MIDI ports.") return 2 except rtmidi.RtMidiError as exc: log.error(exc) return 1 except (EOFError, KeyboardInterrupt): return 0 try: for filename in files: try: send_sysex_file(filename, midiout, portname, args.prompt, args.delay) except StopIteration: break except Exception as exc: log.error("Error while sending file '%s': %s", (filename, exc)) finally: midiout.close_port() del midiout return 0 if __name__ == '__main__': sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2484176 python-rtmidi-1.4.7/examples/sequencer/0000755000175000001440000000000000000000000017172 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sequencer/sequencer.py0000644000175000001440000001576300000000000021552 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # sequencer.py # """Example of using a thread to send out queued-up, timed MIDI messages.""" import logging import threading import time from collections import deque from heapq import heappush, heappop try: range = xrange # noqa except NameError: pass log = logging.getLogger(__name__) class MidiEvent(object): """Container for a MIDI message and a timing tick. Bascially like a two-item named tuple, but we overwrite the comparison operators, so that they (except when testing for equality) use only the timing ticks. """ __slots__ = ('tick', 'message') def __init__(self, tick, message): self.tick = tick self.message = message def __repr__(self): return "@ %05i %r" % (self.tick, self.message) def __eq__(self, other): return (self.tick == other.tick and self.message == other.message) def __lt__(self, other): return self.tick < other.tick def __le__(self, other): return self.tick <= other.tick def __gt__(self, other): return self.tick > other.tick def __ge__(self, other): return self.tick >= other.tick class SequencerThread(threading.Thread): def __init__(self, midiout, queue=None, bpm=120.0, ppqn=480): super(SequencerThread, self).__init__() # log.debug("Created sequencer thread.") self.midiout = midiout # inter-thread communication self.queue = queue if queue is None: self.queue = deque() # log.debug("Created queue for MIDI output.") self._stopped = threading.Event() self._finished = threading.Event() # Counts elapsed ticks when sequence is running self._tickcnt = None # Max number of input queue events to get in one loop self._batchsize = 100 # run-time options self.ppqn = ppqn self.bpm = bpm @property def bpm(self): """Return current beats-per-minute value.""" return self._bpm @bpm.setter def bpm(self, value): self._bpm = value self._tick = 60. / value / self.ppqn # log.debug("Changed BPM => %s, tick interval %.2f ms.", # self._bpm, self._tick * 1000) def stop(self, timeout=5): """Set thread stop event, causing it to exit its mainloop.""" self._stopped.set() # log.debug("SequencerThread stop event set.") if self.is_alive(): self._finished.wait(timeout) self.join() def add(self, event, tick=None, delta=0): """Enqueue event for sending to MIDI output.""" if tick is None: tick = self._tickcnt or 0 if not isinstance(event, MidiEvent): event = MidiEvent(tick, event) if not event.tick: event.tick = tick event.tick += delta self.queue.append(event) def get_event(self): """Poll the input queue for events without blocking. Could be overwritten, e.g. if you passed in your own queue instance with a different API. """ try: return self.queue.popleft() except IndexError: return None def handle_event(self, event): """Handle the event by sending it to MIDI out. Could be overwritten, e.g. to handle meta events, like time signature and tick division changes. """ # log.debug("Midi Out: %r", event.message) self.midiout.send_message(event.message) def run(self): """Start the thread's main loop. The thread will watch for events on the input queue and either send them immediately to the MIDI output or queue them for later output, if their timestamp has not been reached yet. """ # busy loop to wait for time when next batch of events needs to # be written to output pending = [] self._tickcnt = 0 try: while not self._stopped.is_set(): due = [] curtime = time.time() # Pop events off the pending queue # if they are due for this tick while True: if not pending or pending[0].tick > self._tickcnt: break evt = heappop(pending) heappush(due, evt) # log.debug("Queued pending event for output: %r", evt) # Pop up to self._batchsize events off the input queue for i in range(self._batchsize): evt = self.get_event() if not evt: break # log.debug("Got event from input queue: %r", evt) # Check whether event should be sent out immediately # or needs to be scheduled if evt.tick <= self._tickcnt: heappush(due, evt) # log.debug("Queued event for output.") else: heappush(pending, evt) # log.debug("Scheduled event in pending queue.") # If this batch contains any due events, # send them to the MIDI output. if due: for i in range(len(due)): self.handle_event(heappop(due)) # loop speed adjustment elapsed = time.time() - curtime if elapsed < self._tick: time.sleep(self._tick - elapsed) self._tickcnt += 1 except KeyboardInterrupt: # log.debug("KeyboardInterrupt / INT signal received.") pass # log.debug("Midi output mainloop exited.") self._finished.set() def _test(): import sys from rtmidi.midiconstants import NOTE_ON, NOTE_OFF from rtmidi.midiutil import open_midiport logging.basicConfig(level=logging.DEBUG, format="%(message)s") try: midiout, port = open_midiport( sys.argv[1] if len(sys.argv) > 1 else None, "output", client_name="RtMidi Sequencer") except (IOError, ValueError) as exc: return "Could not open MIDI input: %s" % exc except (EOFError, KeyboardInterrupt): return seq = SequencerThread(midiout, bpm=100, ppqn=240) def add_quarter(tick, note, vel=100): seq.add((NOTE_ON, note, vel), tick) seq.add((NOTE_OFF, note, 0), tick=tick + seq.ppqn) t = 0 p = seq.ppqn add_quarter(t, 60) add_quarter(t + p, 64) add_quarter(t + p * 2, 67) add_quarter(t + p * 3, 72) t = p * 5 add_quarter(t, 60) add_quarter(t + p, 64) add_quarter(t + p * 2, 67) add_quarter(t + p * 3, 72) try: seq.start() time.sleep(60. / seq.bpm * 4) seq.bpm = 150 time.sleep(60. / seq.bpm * 6) finally: seq.stop() midiout.close_port() del midiout if __name__ == '__main__': _test() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2494175 python-rtmidi-1.4.7/examples/sysex/0000755000175000001440000000000000000000000016353 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611776280.0 python-rtmidi-1.4.7/examples/sysex/send_sysex.py0000755000175000001440000000135100000000000021114 0ustar00chrisusers#!/usr/bin/env python import argparse import sys import time from rtmidi.midiutil import open_midioutput def main(args=None): ap = argparse.ArgumentParser() ap.add_argument("-p", "--port", help="MIDI output port") ap.add_argument("sysex-byte", nargs="+", help="SysEx bytes as hexadecimal") args = ap.parse_args() midiout, name = open_midioutput(args.port) print("Opened port '%s'." % name) data = bytearray.fromhex("".join(getattr(args, "sysex-byte"))) assert data[0] == 0xF0 and data[-1] == 0xF7 print("Sending %d bytes" % len(data)) midiout.send_message(data) time.sleep(0.5) midiout.close_port() del midiout if __name__ == "__main__": sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611776284.0 python-rtmidi-1.4.7/examples/sysex/send_sysex_file.py0000755000175000001440000000204000000000000022107 0ustar00chrisusers#!/usr/bin/env python import argparse import sys import time from rtmidi.midiutil import open_midioutput def main(args=None): ap = argparse.ArgumentParser() ap.add_argument("-p", "--port", help="MIDI output port") ap.add_argument("-l", "--length", type=int, help="Maximum SysEx message length in bytes per file.") ap.add_argument("sysex-file", nargs="+", help="SysEx input file(s)") args = ap.parse_args() midiout, name = open_midioutput(args.port) print("Opened port '%s'." % name) for filename in getattr(args, "sysex-file"): with open(filename, 'rb') as syx: data = syx.read() assert data[0] == 0xF0 and data[-1] == 0xF7 if args.length: data = bytearray(data[:args.length]) data[-1] = 0xF7 print("Sending %d bytes from '%s'..." % (len(data), filename)) midiout.send_message(data) time.sleep(0.5) midiout.close_port() del midiout if __name__ == "__main__": sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2494175 python-rtmidi-1.4.7/examples/sysexsaver/0000755000175000001440000000000000000000000017414 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sysexsaver/__init__.py0000644000175000001440000000000000000000000021513 0ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sysexsaver/__main__.py0000644000175000001440000001555600000000000021522 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # sysexsaver.py # """Save all revceived sysex messages to given directory.""" import argparse import logging import os import re import sys import time from datetime import datetime from os.path import exists, join from rtmidi.midiconstants import END_OF_EXCLUSIVE, SYSTEM_EXCLUSIVE from rtmidi.midiutil import open_midiinput from .manufacturers import manufacturers from .models import models log = logging.getLogger('sysexsaver') def sanitize_name(s, replace='/?*&\\'): s = s.strip() s = re.sub(r'\s+', '_', s) for c in replace: s = s.replace(c, '_') return s.lower() class SysexMessage(object): @classmethod def fromdata(cls, data): self = cls() if data[0] != SYSTEM_EXCLUSIVE: raise ValueError("Message does not start with 0xF0", data) if data[-1] != END_OF_EXCLUSIVE: raise ValueError("Message does not end with 0xF7", data) if len(data) < 5: raise ValueError("Message too short", data) if data[1] == 0: self.manufacturer_id = (data[1], data[2], data[3]) self.model_id = data[5] self.device_id = data[6] else: self.manufacturer_id = data[1] self.model_id = data[2] self.device_id = data[3] self._data = data return self def __getitem__(self, i): return self._data[i] def __getslice(self, i, j): return self._data[i:j] @property def manufacturer(self): mname = manufacturers.get(self.manufacturer_id) if mname: return mname[0] @property def manufacturer_tag(self): mname = manufacturers.get(self.manufacturer_id, []) if len(mname) >= 2: return mname[1] elif mname: return mname[0] @property def model(self): model_name = models.get(self.manufacturer_id, {}).get(self.model_id) return model_name[0] if model_name else "0x%02X" % self.model_id @property def model_tag(self): model_name = models.get(self.manufacturer_id, {}).get(self.model_id, []) if len(model_name) >= 2: return model_name[1] elif model_name: return model_name[1] else: "0x%02X" % self.model_id def __repr__(self): return "".join(["%02X " % b for b in self._data]) def as_bytes(self): if bytes == str: return "".join([chr(b) for b in self._data]) else: return bytes(self._data) class SysexSaver(object): """MIDI input callback handler object.""" fn_tmpl = "%(manufacturer)s-%(device)s-%(timestamp)s.syx" fn_named_tmpl = "%(manufacturer)s-%(device)s-%(name)s-%(timestamp)s.syx" def __init__(self, portname, directory, debug=False): self.portname = portname self.directory = directory self.debug = debug def __call__(self, event, data=None): try: message, deltatime = event if message[:1] != [SYSTEM_EXCLUSIVE]: return dt = datetime.now() log.debug("[%s: %s] Received sysex msg of %i bytes." % ( self.portname, dt.strftime('%x %X'), len(message))) sysex = SysexMessage.fromdata(message) # XXX: This should be implemented in a subclass # loaded via a plugin infrastructure data = dict(timestamp=dt.strftime('%Y%m%dT%H%M%S.%f')) data['manufacturer'] = sanitize_name( sysex.manufacturer_tag or 'unknown') data['device'] = sanitize_name(sysex.model_tag or 'unknown') if sysex.manufacturer_id == 62 and sysex.model_id == 0x0E: if sysex[4] == 0x10: # sound dump name = "".join(chr(c) for c in sysex[247:263]).rstrip('_') elif sysex[4] == 0x11: # multi dump name = "".join(chr(c) for c in sysex[23:38]).rstrip('_') elif sysex[4] == 0x12: # wave dump if sysex[5] > 1: name = "userwave_%04i" else: name = "romwave_%03i" name = name % ((sysex[5] << 7) | sysex[6]) elif sysex[4] == 0x13: # wave table dump if sysex[6] >= 96: name = "userwavetable_%03i" % (sysex[6] + 1) else: name = "romwavetable_%03i" % (sysex[6] + 1) else: name = "%02X" % sysex[4] data['name'] = sanitize_name(name) outfn = join(self.directory, ( self.fn_named_tmpl if 'name' in data else self.fn_tmpl) % data) if exists(outfn): log.error("Output file already exists, will not overwrite.") else: data = sysex.as_bytes() with open(outfn, 'wb') as outfile: outfile.write(data) log.info("Sysex message of %i bytes written to '%s'.", len(data), outfn) except Exception as exc: msg = "Error handling MIDI message: %s" % exc.args[0] if self.debug: log.debug(msg) if len(exc.args) >= 2: log.debug("Message data: %r", exc.args[1]) else: log.error(msg) def main(args=None): """Save revceived sysex message to directory given on command line.""" parser = argparse.ArgumentParser(description=__doc__) padd = parser.add_argument padd('-o', '--outdir', default=os.getcwd(), help="Output directory (default: current working directory).") padd('-p', '--port', help='MIDI output port number (default: ask)') padd('-v', '--verbose', action="store_true", help='verbose output') args = parser.parse_args(args) logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG if args.verbose else logging.INFO) try: midiin, port = open_midiinput(args.port) except IOError as exc: log.error(exc) return 1 except (EOFError, KeyboardInterrupt): return 0 ss = SysexSaver(port, args.outdir, args.verbose) log.debug("Attaching MIDI input callback handler.") midiin.set_callback(ss) log.debug("Enabling reception of sysex messages.") midiin.ignore_types(sysex=False) log.info("Waiting for sysex reception. Press Control-C to exit.") try: # just wait for keyboard interrupt in main thread while True: time.sleep(1) except KeyboardInterrupt: print('') finally: log.debug("Exit.") midiin.close_port() del midiin if __name__ == '__main__': sys.exit(main() or 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sysexsaver/manufacturers.csv0000644000175000001440000002634500000000000023022 0ustar00chrisusers"id";"name";"shortname" (0x00, 0x00, 0x07);"Digital Music Corporation"; (0x00, 0x00, 0x0E);"Alesis"; (0x00, 0x00, 0x15);"KAT"; (0x00, 0x00, 0x16);"Opcode"; (0x00, 0x00, 0x1A);"Allen & Heath Brenell"; (0x00, 0x00, 0x1B);"Peavey Electronics"; (0x00, 0x00, 0x1C);"360 Systems"; (0x00, 0x00, 0x20);"Axxes"; (0x00, 0x00, 0x74);"Ta Horng Musical Instrument"; (0x00, 0x00, 0x75);"e-Tek Labs (Forte Tech)"; (0x00, 0x00, 0x76);"Electro-Voice"; (0x00, 0x00, 0x77);"Midisoft Corporation";"Midisoft" (0x00, 0x00, 0x78);"QSound Labs"; (0x00, 0x00, 0x79);"Westrex"; (0x00, 0x00, 0x7A);"Nvidia"; (0x00, 0x00, 0x7B);"ESS Technology"; (0x00, 0x00, 0x7C);"Media Trix Peripherals"; (0x00, 0x00, 0x7D);"Brooktree Corp"; (0x00, 0x00, 0x7E);"Otari Corp"; (0x00, 0x00, 0x7F);"Key Electronics, Inc."; (0x00, 0x01, 0x00);"Shure Incorporated"; (0x00, 0x01, 0x01);"AuraSound"; (0x00, 0x01, 0x02);"Crystal Semiconductor"; (0x00, 0x01, 0x03);"Conexant (Rockwell)";"Conexant" (0x00, 0x01, 0x04);"Silicon Graphics";"SGI" (0x00, 0x01, 0x05);"M-Audio (Midiman)"; (0x00, 0x01, 0x06);"PreSonus"; (0x00, 0x01, 0x08);"Topaz Enterprises"; (0x00, 0x01, 0x09);"Cast Lighting"; (0x00, 0x01, 0x0A);"Microsoft"; (0x00, 0x01, 0x0B);"Sonic Foundry"; (0x00, 0x01, 0x0C);"Line 6 (Fast Forward)";"Line 6" (0x00, 0x01, 0x0D);"Beatnik Inc";"Beatnik" (0x00, 0x01, 0x0E);"Van Koevering Company"; (0x00, 0x01, 0x0F);"Altech Systems"; (0x00, 0x01, 0x10);"S & S Research"; (0x00, 0x01, 0x11);"VLSI Technology"; (0x00, 0x01, 0x12);"Chromatic Research"; (0x00, 0x01, 0x13);"Sapphire"; (0x00, 0x01, 0x14);"IDRC"; (0x00, 0x01, 0x15);"Justonic Tuning"; (0x00, 0x01, 0x16);"TorComp Research Inc."; (0x00, 0x01, 0x17);"Newtek Inc."; (0x00, 0x01, 0x18);"Sound Sculpture"; (0x00, 0x01, 0x19);"Walker Technical"; (0x00, 0x01, 0x1A);"Digital Harmony (PAVO)"; (0x00, 0x01, 0x1B);"InVision Interactive"; (0x00, 0x01, 0x1C);"T-Square Design"; (0x00, 0x01, 0x1D);"Nemesys Music Technology"; (0x00, 0x01, 0x1E);"DBX Professional (Harman Intl)";"DBX" (0x00, 0x01, 0x1F);"Syndyne Corporation"; (0x00, 0x01, 0x20);"Bitheadz"; (0x00, 0x01, 0x21);"Cakewalk Music Software";"Cakewalk" (0x00, 0x01, 0x22);"Analog Devices"; (0x00, 0x01, 0x23);"National Semiconductor"; (0x00, 0x01, 0x24);"Boom Theory / Adinolfi Alternative Percussion"; (0x00, 0x01, 0x25);"Virtual DSP Corporation"; (0x00, 0x01, 0x26);"Antares Systems"; (0x00, 0x01, 0x27);"Angel Software"; (0x00, 0x01, 0x28);"St Louis Music"; (0x00, 0x01, 0x29);"Lyrrus dba G-VOX"; (0x00, 0x01, 0x2A);"Ashley Audio Inc."; (0x00, 0x01, 0x2B);"Vari-Lite Inc."; (0x00, 0x01, 0x2C);"Summit Audio Inc."; (0x00, 0x01, 0x2D);"Aureal Semiconductor Inc."; (0x00, 0x01, 0x2E);"SeaSound LLC"; (0x00, 0x01, 0x2F);"U.S. Robotics"; (0x00, 0x01, 0x30);"Aurisis Research"; (0x00, 0x01, 0x31);"Nearfield Research"; (0x00, 0x01, 0x32);"FM7 Inc"; (0x00, 0x01, 0x33);"Swivel Systems"; (0x00, 0x01, 0x34);"Hyperactive Audio Systems"; (0x00, 0x01, 0x35);"MidiLite (Castle Studios Productions)";"MidiLite" (0x00, 0x01, 0x36);"Radikal Technologies"; (0x00, 0x01, 0x37);"Roger Linn Design"; (0x00, 0x01, 0x38);"TC-Helicon Vocal Technologies"; (0x00, 0x01, 0x39);"Event Electronics"; (0x00, 0x01, 0x3A);"Sonic Network Inc"; (0x00, 0x01, 0x3B);"Realtime Music Solutions"; (0x00, 0x01, 0x3C);"Apogee Digital";"Apogee" (0x00, 0x01, 0x3D);"Classical Organs, Inc."; (0x00, 0x01, 0x3E);"Microtools Inc."; (0x00, 0x01, 0x3F);"Numark Industries"; (0x00, 0x01, 0x40);"Frontier Design Group, LLC"; (0x00, 0x01, 0x41);"Recordare LLC"; (0x00, 0x01, 0x42);"Starr Labs"; (0x00, 0x01, 0x43);"Voyager Sound Inc."; (0x00, 0x01, 0x44);"Manifold Labs"; (0x00, 0x01, 0x45);"Aviom Inc.";"Aviom" (0x00, 0x01, 0x46);"Mixmeister Technology"; (0x00, 0x01, 0x47);"Notation Software"; (0x00, 0x01, 0x48);"Mercurial Communications"; (0x00, 0x01, 0x49);"Wave Arts"; (0x00, 0x01, 0x4A);"Logic Sequencing Devices"; (0x00, 0x01, 0x4B);"Axess Electronics";"Axess" (0x00, 0x01, 0x4C);"Muse Research"; (0x00, 0x01, 0x4D);"Open Labs"; (0x00, 0x01, 0x4E);"Guillemot R&D Inc"; (0x00, 0x01, 0x4F);"Samson Technologies"; (0x00, 0x01, 0x50);"Electronic Theatre Controls"; (0x00, 0x01, 0x51);"Blackberry (RIM)";"Blackberry" (0x00, 0x01, 0x52);"Mobileer"; (0x00, 0x01, 0x53);"Synthogy"; (0x00, 0x01, 0x54);"Lynx Studio Technology Inc."; (0x00, 0x01, 0x55);"Damage Control Engineering LLC"; (0x00, 0x01, 0x56);"Yost Engineering, Inc."; (0x00, 0x01, 0x57);"Brooks & Forsman Designs LLC / DrumLite"; (0x00, 0x01, 0x58);"Infinite Response"; (0x00, 0x01, 0x59);"Garritan Corp"; (0x00, 0x01, 0x5A);"Plogue Art et Technologie, Inc"; (0x00, 0x01, 0x5B);"RJM Music Technology"; (0x00, 0x01, 0x5C);"Custom Solutions Software"; (0x00, 0x01, 0x5D);"Sonarcana LLC"; (0x00, 0x01, 0x5E);"Centrance"; (0x00, 0x01, 0x5F);"Kesumo LLC"; (0x00, 0x01, 0x60);"Stanton (Gibson)"; (0x00, 0x01, 0x61);"Livid Instruments"; (0x00, 0x01, 0x62);"First Act / 745 Media"; (0x00, 0x01, 0x63);"Pygraphics, Inc."; (0x00, 0x01, 0x64);"Panadigm Innovations Ltd"; (0x00, 0x01, 0x65);"Avedis Zildjian Co"; (0x00, 0x01, 0x66);"Auvital Music Corp"; (0x00, 0x01, 0x67);"Inspired Instruments Inc"; (0x00, 0x01, 0x68);"Chris Grigg Designs"; (0x00, 0x01, 0x69);"Slate Digital LLC"; (0x00, 0x01, 0x6A);"Mixware"; (0x00, 0x01, 0x6B);"Social Entropy"; (0x00, 0x01, 0x6C);"Source Audio LLC"; (0x00, 0x01, 0x6D);"Ernie Ball / Music Man"; (0x00, 0x01, 0x6E);"Fishman Transducers"; (0x00, 0x01, 0x6F);"Custom Audio Electronics"; (0x00, 0x01, 0x70);"American Audio/DJ"; (0x00, 0x01, 0x71);"Mega Control Systems"; (0x00, 0x01, 0x72);"Kilpatrick Audio"; (0x00, 0x01, 0x73);"iConnectivity"; (0x00, 0x01, 0x74);"Fractal Audio"; (0x00, 0x01, 0x75);"NetLogic Microsystems"; (0x00, 0x01, 0x76);"Music Computing"; (0x00, 0x01, 0x77);"Nektar Technology Inc"; (0x00, 0x01, 0x78);"Zenph Sound Innovations"; (0x00, 0x01, 0x79);"DJTechTools.com"; (0x00, 0x01, 0x7A);"Rezonance Labs"; (0x00, 0x01, 0x7B);"Decibel Eleven"; (0x00, 0x01, 0x7C);"CNMAT"; (0x00, 0x01, 0x7D);"Media Overkill"; (0x00, 0x01, 0x7E);"Confusionists LLC"; (0x00, 0x20, 0x27);"Acorn Computer"; (0x00, 0x20, 0x29);"Focusrite/Novation";"Novation" (0x00, 0x20, 0x2A);"Samkyung Mechatronics"; (0x00, 0x20, 0x2B);"Medeli Electronics Co."; (0x00, 0x20, 0x2C);"Charlie Lab SRL"; (0x00, 0x20, 0x2D);"Blue Chip Music Technology"; (0x00, 0x20, 0x2E);"BEE OH Corp"; (0x00, 0x20, 0x2F);"LG Semicon America"; (0x00, 0x20, 0x30);"TESI"; (0x00, 0x20, 0x31);"EMAGIC"; (0x00, 0x20, 0x32);"Behringer GmbH";"Behringer" (0x00, 0x20, 0x33);"Access Music Electronics";"Access" (0x00, 0x20, 0x34);"Synoptic"; (0x00, 0x20, 0x35);"Hanmesoft"; (0x00, 0x20, 0x36);"Terratec Electronic GmbH"; (0x00, 0x20, 0x37);"Proel SpA"; (0x00, 0x20, 0x38);"IBK MIDI"; (0x00, 0x20, 0x39);"IRCAM"; (0x00, 0x20, 0x3A);"Propellerhead Software"; (0x00, 0x20, 0x3B);"Red Sound Systems Ltd"; (0x00, 0x20, 0x3C);"Elektron ESI AB"; (0x00, 0x20, 0x3D);"Sintefex Audio"; (0x00, 0x20, 0x3E);"MAM (Music and More)";"MAM" (0x00, 0x20, 0x3F);"Amsaro GmbH"; (0x00, 0x20, 0x40);"CDS Advanced Technology BV"; (0x00, 0x20, 0x41);"Touched By Sound GmbH"; (0x00, 0x20, 0x42);"DSP Arts"; (0x00, 0x20, 0x43);"Phil Rees Music Tech"; (0x00, 0x20, 0x44);"Stamer Musikanlagen GmbH"; (0x00, 0x20, 0x45);"Musical Muntaner S.A. dba Soundart"; (0x00, 0x20, 0x46);"C-Mexx Software";"C-Mexx" (0x00, 0x20, 0x47);"Klavis Technologies"; (0x00, 0x20, 0x48);"Noteheads AB"; (0x00, 0x20, 0x49);"Algorithmix"; (0x00, 0x20, 0x4A);"Skrydstrup R&D"; (0x00, 0x20, 0x4B);"Professional Audio Company"; (0x00, 0x20, 0x4C);"NewWave Labs (MadWaves)"; (0x00, 0x20, 0x4D);"Vermona"; (0x00, 0x20, 0x4E);"Nokia"; (0x00, 0x20, 0x4F);"Wave Idea"; (0x00, 0x20, 0x50);"Hartmann GmbH"; (0x00, 0x20, 0x51);"Lion's Tracs"; (0x00, 0x20, 0x52);"Analogue Systems"; (0x00, 0x20, 0x53);"Focal-JMlab"; (0x00, 0x20, 0x54);"Ringway Electronics (Chang-Zhou) Co Ltd"; (0x00, 0x20, 0x55);"Faith Technologies (Digiplug)"; (0x00, 0x20, 0x56);"Showworks"; (0x00, 0x20, 0x57);"Manikin Electronic";"Manikin" (0x00, 0x20, 0x58);"1 Come Tech"; (0x00, 0x20, 0x59);"Phonic Corp"; (0x00, 0x20, 0x5A);"Dolby Australia (Lake)"; (0x00, 0x20, 0x5B);"Silansys Technologies"; (0x00, 0x20, 0x5C);"Winbond Electronics"; (0x00, 0x20, 0x5D);"Cinetix Medien und Interface GmbH"; (0x00, 0x20, 0x5E);"A&G Soluzioni Digitali"; (0x00, 0x20, 0x5F);"Sequentix Music Systems"; (0x00, 0x20, 0x60);"Oram Pro Audio"; (0x00, 0x20, 0x61);"Be4 Ltd"; (0x00, 0x20, 0x62);"Infection Music"; (0x00, 0x20, 0x63);"Central Music Co. (CME)";"CME" (0x00, 0x20, 0x64);"genoQs Machines GmbH"; (0x00, 0x20, 0x65);"Medialon"; (0x00, 0x20, 0x66);"Waves Audio Ltd"; (0x00, 0x20, 0x67);"Jerash Labs"; (0x00, 0x20, 0x68);"Da Fact"; (0x00, 0x20, 0x69);"Elby Designs"; (0x00, 0x20, 0x6A);"Spectral Audio"; (0x00, 0x20, 0x6B);"Arturia"; (0x00, 0x20, 0x6C);"Vixid"; (0x00, 0x20, 0x6D);"C-Thru Music"; (0x00, 0x20, 0x6E);"Ya Horng Electronic Co LTD"; (0x00, 0x20, 0x6F);"SM Pro Audio"; (0x00, 0x20, 0x70);"OTO MACHINES"; (0x00, 0x20, 0x71);"ELZAB S.A., G LAB"; (0x00, 0x20, 0x72);"Blackstar Amplification Ltd"; (0x00, 0x20, 0x73);"M3i Technologies GmbH"; (0x00, 0x20, 0x74);"Gemalto (from Xiring)"; (0x00, 0x20, 0x75);"Prostage SL"; (0x00, 0x20, 0x76);"Teenage Engineering"; (0x00, 0x20, 0x77);"Tobias Erichsen Consulting"; (0x00, 0x20, 0x78);"Nixer Ltd"; (0x00, 0x20, 0x79);"Hanpin Electron Co Ltd"; (0x00, 0x20, 0x7A);"""MIDI-hardware"" R.Sowa"; (0x00, 0x20, 0x7B);"Beyond Music Industrial Ltd"; (0x00, 0x20, 0x7C);"Kiss Box B.V."; (0x00, 0x20, 0x7D);"Misa Digital Technologies Ltd"; (0x00, 0x20, 0x7E);"AI Musics Technology Inc"; (0x00, 0x20, 0x7F);"Serato Inc LP"; (0x00, 0x21, 0x00);"Limex Music Handles GmbH"; (0x00, 0x21, 0x01);"Kyodday/Tokai"; (0x00, 0x21, 0x02);"Mutable Instruments"; (0x00, 0x21, 0x03);"PreSonus Software Ltd";"PreSonus" (0x00, 0x21, 0x04);"Xiring"; (0x00, 0x21, 0x05);"Fairlight Instruments Pty Ltd";"Fairlight" (0x00, 0x21, 0x06);"Musicom Lab"; (0x00, 0x21, 0x07);"VacoLoco"; (0x00, 0x21, 0x08);"RWA (Hong Kong) Limited"; (0x00, 0x21, 0x09);"Native Instruments";"NI" (0x00, 0x21, 0x0A);"Naonext"; (0x00, 0x21, 0x0B);"MFB"; (0x00, 0x21, 0x0C);"Teknel Research"; (0x00, 0x21, 0x0D);"Ploytec GmbH";"Ploytec" (0x00, 0x21, 0x0E);"Surfin Kangaroo Studio"; (0x00, 0x21, 0x0F);"Philips Electronics HK Ltd";"Philips" (0x00, 0x21, 0x10);"ROLI Ltd"; (0x00, 0x40, 0x00);"Crimson Technology Inc."; (0x00, 0x40, 0x01);"Softbank Mobile Corp"; (0x00, 0x40, 0x03);"D&M Holdings Inc."; 0x01;"Sequential Circuits"; 0x04;"Moog"; 0x06;"Lexicon"; 0x07;"Kurzweil"; 0x0F;"Ensoniq"; 0x10;"Oberheim"; 0x11;"Apple"; 0x18;"Emu"; 0x1A;"ART"; 0x22;"Synthaxe"; 0x24;"Hohner"; 0x29;"PPG"; 0x2B;"SSL"; 0x2F;"Elka / General Music";"GEM" 0x30;"Dynacord"; 0x33;"Clavia (Nord)";"Clavia" 0x36;"Cheetah"; 0x3E;"Waldorf Electronics Gmbh";"Waldorf" 0x40;"Kawai Musical Instruments MFG. CO. Ltd";"Kawai" 0x41;"Roland Corporation";"Roland" 0x42;"Korg Inc.";"Korg" 0x43;"Yamaha Corporation";"Yamaha" 0x44;"Casio Computer Co. Ltd";"Casio" 0x46;"Kamiya Studio Co. Ltd"; 0x47;"Akai Electric Co. Ltd.";"Akai" 0x48;"Victor Company of Japan, Ltd.";"JVC" 0x4B;"Fujitsu Limited";"Fujitsu" 0x4C;"Sony Corporation";"Sony" 0x4E;"Teac Corporation";"Teac" 0x50;"Matsushita Electric Industrial Co. , Ltd";"M-Audio" 0x51;"Fostex Corporation";"Fostex" 0x52;"Zoom Corporation";"Zoom" 0x54;"Matsushita Communication Industrial Co., Ltd."; 0x55;"Suzuki Musical Instruments MFG. Co., Ltd.";"Suzuki" 0x56;"Fuji Sound Corporation Ltd.";"Fuji" 0x57;"Acoustic Technical Laboratory, Inc."; 0x59;"Faith, Inc."; 0x5A;"Internet Corporation"; 0x5C;"Seekers Co. Ltd."; 0x5F;"SD Card Association"; ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sysexsaver/manufacturers.py0000644000175000001440000003006100000000000022645 0ustar00chrisusers# -*- coding: utf-8 -*- """Map manufacturer ID to manufacturer name and short name.""" manufacturers = { # id: (name, shortname), 1: ('Sequential Circuits',), 4: ('Moog',), 6: ('Lexicon',), 7: ('Kurzweil',), 15: ('Ensoniq',), 16: ('Oberheim',), 17: ('Apple',), 24: ('Emu',), 26: ('ART',), 34: ('Synthaxe',), 36: ('Hohner',), 41: ('PPG',), 43: ('SSL',), 47: ('Elka / General Music', 'GEM'), 48: ('Dynacord',), 51: ('Clavia (Nord)', 'Clavia'), 54: ('Cheetah',), 62: ('Waldorf Electronics Gmbh', 'Waldorf'), 64: ('Kawai Musical Instruments MFG. CO. Ltd', 'Kawai'), 65: ('Roland Corporation', 'Roland'), 66: ('Korg Inc.', 'Korg'), 67: ('Yamaha Corporation', 'Yamaha'), 68: ('Casio Computer Co. Ltd', 'Casio'), 70: ('Kamiya Studio Co. Ltd', 'Kamiya'), 71: ('Akai Electric Co. Ltd.', 'Akai'), 72: ('Victor Company of Japan, Ltd.', 'JVC'), 75: ('Fujitsu Limited', 'Fujitsu'), 76: ('Sony Corporation', 'Sony'), 78: ('Teac Corporation', 'Teac'), 80: ('Matsushita Electric Industrial Co. , Ltd', 'M-Audio'), 81: ('Fostex Corporation', 'Fostex'), 82: ('Zoom Corporation', 'Zoom'), 84: ('Matsushita Communication Industrial Co., Ltd.', 'Matsushita'), 85: ('Suzuki Musical Instruments MFG. Co., Ltd.', 'Suzuki'), 86: ('Fuji Sound Corporation Ltd.', 'Fuji'), 87: ('Acoustic Technical Laboratory, Inc.', 'ATL'), 89: ('Faith, Inc.', 'Faith'), 90: ('Internet Corporation',), 92: ('Seekers Co. Ltd.', 'Seekers'), 95: ('SD Card Association',), 0x7D: ('Non-commercial',), 0x7E: ('Universal Non-Realtime',), 0x7F: ('Universal Realtime',), (0, 0, 7): ('Digital Music Corporation',), (0, 0, 14): ('Alesis',), (0, 0, 21): ('KAT',), (0, 0, 22): ('Opcode',), (0, 0, 26): ('Allen & Heath Brenell', 'Allen & Heath'), (0, 0, 27): ('Peavey Electronics', 'Peavey'), (0, 0, 28): ('360 Systems',), (0, 0, 32): ('Axxes',), (0, 0, 116): ('Ta Horng Musical Instrument',), (0, 0, 117): ('e-Tek Labs (Forte Tech)', 'e-Tek Labs'), (0, 0, 118): ('Electro-Voice',), (0, 0, 119): ('Midisoft Corporation', 'Midisoft'), (0, 0, 120): ('QSound Labs',), (0, 0, 121): ('Westrex',), (0, 0, 122): ('Nvidia',), (0, 0, 123): ('ESS Technology', 'ESS'), (0, 0, 124): ('Media Trix Peripherals',), (0, 0, 125): ('Brooktree Corp',), (0, 0, 126): ('Otari Corp',), (0, 0, 127): ('Key Electronics, Inc.',), (0, 1, 0): ('Shure Incorporated', 'Shure'), (0, 1, 1): ('AuraSound',), (0, 1, 2): ('Crystal Semiconductor', 'Crystal'), (0, 1, 3): ('Conexant (Rockwell)', 'Conexant'), (0, 1, 4): ('Silicon Graphics', 'SGI'), (0, 1, 5): ('M-Audio (Midiman)', 'M-Audio'), (0, 1, 6): ('PreSonus',), (0, 1, 8): ('Topaz Enterprises', 'Topaz'), (0, 1, 9): ('Cast Lighting',), (0, 1, 10): ('Microsoft',), (0, 1, 11): ('Sonic Foundry',), (0, 1, 12): ('Line 6 (Fast Forward)', 'Line 6'), (0, 1, 13): ('Beatnik Inc', 'Beatnik'), (0, 1, 14): ('Van Koevering Company',), (0, 1, 15): ('Altech Systems',), (0, 1, 16): ('S & S Research',), (0, 1, 17): ('VLSI Technology',), (0, 1, 18): ('Chromatic Research',), (0, 1, 19): ('Sapphire',), (0, 1, 20): ('IDRC',), (0, 1, 21): ('Justonic Tuning',), (0, 1, 22): ('TorComp Research Inc.',), (0, 1, 23): ('Newtek Inc.',), (0, 1, 24): ('Sound Sculpture',), (0, 1, 25): ('Walker Technical',), (0, 1, 26): ('Digital Harmony (PAVO)',), (0, 1, 27): ('InVision Interactive',), (0, 1, 28): ('T-Square Design',), (0, 1, 29): ('Nemesys Music Technology',), (0, 1, 30): ('DBX Professional (Harman Intl)', 'DBX'), (0, 1, 31): ('Syndyne Corporation',), (0, 1, 32): ('Bitheadz',), (0, 1, 33): ('Cakewalk Music Software', 'Cakewalk'), (0, 1, 34): ('Analog Devices',), (0, 1, 35): ('National Semiconductor',), (0, 1, 36): ('Boom Theory / Adinolfi Alternative Percussion',), (0, 1, 37): ('Virtual DSP Corporation',), (0, 1, 38): ('Antares Systems',), (0, 1, 39): ('Angel Software',), (0, 1, 40): ('St Louis Music',), (0, 1, 41): ('Lyrrus dba G-VOX',), (0, 1, 42): ('Ashley Audio Inc.',), (0, 1, 43): ('Vari-Lite Inc.',), (0, 1, 44): ('Summit Audio Inc.',), (0, 1, 45): ('Aureal Semiconductor Inc.',), (0, 1, 46): ('SeaSound LLC',), (0, 1, 47): ('U.S. Robotics',), (0, 1, 48): ('Aurisis Research',), (0, 1, 49): ('Nearfield Research',), (0, 1, 50): ('FM7 Inc',), (0, 1, 51): ('Swivel Systems',), (0, 1, 52): ('Hyperactive Audio Systems',), (0, 1, 53): ('MidiLite (Castle Studios Productions)', 'MidiLite'), (0, 1, 54): ('Radikal Technologies',), (0, 1, 55): ('Roger Linn Design', 'LINN'), (0, 1, 56): ('TC-Helicon Vocal Technologies',), (0, 1, 57): ('Event Electronics',), (0, 1, 58): ('Sonic Network Inc',), (0, 1, 59): ('Realtime Music Solutions',), (0, 1, 60): ('Apogee Digital', 'Apogee'), (0, 1, 61): ('Classical Organs, Inc.',), (0, 1, 62): ('Microtools Inc.',), (0, 1, 63): ('Numark Industries', 'Numark'), (0, 1, 64): ('Frontier Design Group, LLC',), (0, 1, 65): ('Recordare LLC',), (0, 1, 66): ('Starr Labs',), (0, 1, 67): ('Voyager Sound Inc.',), (0, 1, 68): ('Manifold Labs',), (0, 1, 69): ('Aviom Inc.', 'Aviom'), (0, 1, 70): ('Mixmeister Technology',), (0, 1, 71): ('Notation Software',), (0, 1, 72): ('Mercurial Communications',), (0, 1, 73): ('Wave Arts',), (0, 1, 74): ('Logic Sequencing Devices',), (0, 1, 75): ('Axess Electronics', 'Axess'), (0, 1, 76): ('Muse Research',), (0, 1, 77): ('Open Labs',), (0, 1, 78): ('Guillemot R&D Inc',), (0, 1, 79): ('Samson Technologies',), (0, 1, 80): ('Electronic Theatre Controls',), (0, 1, 81): ('Blackberry (RIM)', 'Blackberry'), (0, 1, 82): ('Mobileer',), (0, 1, 83): ('Synthogy',), (0, 1, 84): ('Lynx Studio Technology Inc.',), (0, 1, 85): ('Damage Control Engineering LLC',), (0, 1, 86): ('Yost Engineering, Inc.',), (0, 1, 87): ('Brooks & Forsman Designs LLC / DrumLite',), (0, 1, 88): ('Infinite Response',), (0, 1, 89): ('Garritan Corp', 'Garritan'), (0, 1, 90): ('Plogue Art et Technologie, Inc',), (0, 1, 91): ('RJM Music Technology',), (0, 1, 92): ('Custom Solutions Software',), (0, 1, 93): ('Sonarcana LLC',), (0, 1, 94): ('Centrance',), (0, 1, 95): ('Kesumo LLC',), (0, 1, 96): ('Stanton (Gibson)',), (0, 1, 97): ('Livid Instruments',), (0, 1, 98): ('First Act / 745 Media',), (0, 1, 99): ('Pygraphics, Inc.',), (0, 1, 100): ('Panadigm Innovations Ltd',), (0, 1, 101): ('Avedis Zildjian Co',), (0, 1, 102): ('Auvital Music Corp',), (0, 1, 103): ('Inspired Instruments Inc',), (0, 1, 104): ('Chris Grigg Designs',), (0, 1, 105): ('Slate Digital LLC',), (0, 1, 106): ('Mixware',), (0, 1, 107): ('Social Entropy',), (0, 1, 108): ('Source Audio LLC',), (0, 1, 109): ('Ernie Ball / Music Man', 'Music Man'), (0, 1, 110): ('Fishman Transducers',), (0, 1, 111): ('Custom Audio Electronics',), (0, 1, 112): ('American Audio/DJ',), (0, 1, 113): ('Mega Control Systems',), (0, 1, 114): ('Kilpatrick Audio',), (0, 1, 115): ('iConnectivity',), (0, 1, 116): ('Fractal Audio',), (0, 1, 117): ('NetLogic Microsystems',), (0, 1, 118): ('Music Computing',), (0, 1, 119): ('Nektar Technology Inc',), (0, 1, 120): ('Zenph Sound Innovations',), (0, 1, 121): ('DJTechTools.com',), (0, 1, 122): ('Rezonance Labs',), (0, 1, 123): ('Decibel Eleven',), (0, 1, 124): ('CNMAT',), (0, 1, 125): ('Media Overkill',), (0, 1, 126): ('Confusionists LLC',), (0, 32, 39): ('Acorn Computer',), (0, 32, 41): ('Focusrite/Novation', 'Novation'), (0, 32, 42): ('Samkyung Mechatronics',), (0, 32, 43): ('Medeli Electronics Co.',), (0, 32, 44): ('Charlie Lab SRL',), (0, 32, 45): ('Blue Chip Music Technology',), (0, 32, 46): ('BEE OH Corp',), (0, 32, 47): ('LG Semicon America',), (0, 32, 48): ('TESI',), (0, 32, 49): ('EMAGIC',), (0, 32, 50): ('Behringer GmbH', 'Behringer'), (0, 32, 51): ('Access Music Electronics', 'Access'), (0, 32, 52): ('Synoptic',), (0, 32, 53): ('Hanmesoft',), (0, 32, 54): ('Terratec Electronic GmbH', 'Terratec'), (0, 32, 55): ('Proel SpA',), (0, 32, 56): ('IBK MIDI',), (0, 32, 57): ('IRCAM',), (0, 32, 58): ('Propellerhead Software',), (0, 32, 59): ('Red Sound Systems Ltd',), (0, 32, 60): ('Elektron ESI AB',), (0, 32, 61): ('Sintefex Audio',), (0, 32, 62): ('MAM (Music and More)', 'MAM'), (0, 32, 63): ('Amsaro GmbH',), (0, 32, 64): ('CDS Advanced Technology BV',), (0, 32, 65): ('Touched By Sound GmbH',), (0, 32, 66): ('DSP Arts',), (0, 32, 67): ('Phil Rees Music Tech',), (0, 32, 68): ('Stamer Musikanlagen GmbH',), (0, 32, 69): ('Musical Muntaner S.A. dba Soundart',), (0, 32, 70): ('C-Mexx Software', 'C-Mexx'), (0, 32, 71): ('Klavis Technologies',), (0, 32, 72): ('Noteheads AB',), (0, 32, 73): ('Algorithmix',), (0, 32, 74): ('Skrydstrup R&D',), (0, 32, 75): ('Professional Audio Company',), (0, 32, 76): ('NewWave Labs (MadWaves)',), (0, 32, 77): ('Vermona',), (0, 32, 78): ('Nokia',), (0, 32, 79): ('Wave Idea',), (0, 32, 80): ('Hartmann GmbH', 'Hartmann'), (0, 32, 81): ("Lion's Tracs",), (0, 32, 82): ('Analogue Systems',), (0, 32, 83): ('Focal-JMlab',), (0, 32, 84): ('Ringway Electronics (Chang-Zhou) Co Ltd',), (0, 32, 85): ('Faith Technologies (Digiplug)',), (0, 32, 86): ('Showworks',), (0, 32, 87): ('Manikin Electronic', 'Manikin'), (0, 32, 88): ('1 Come Tech',), (0, 32, 89): ('Phonic Corp',), (0, 32, 90): ('Dolby Australia (Lake)',), (0, 32, 91): ('Silansys Technologies',), (0, 32, 92): ('Winbond Electronics',), (0, 32, 93): ('Cinetix Medien und Interface GmbH',), (0, 32, 94): ('A&G Soluzioni Digitali',), (0, 32, 95): ('Sequentix Music Systems',), (0, 32, 96): ('Oram Pro Audio',), (0, 32, 97): ('Be4 Ltd',), (0, 32, 98): ('Infection Music',), (0, 32, 99): ('Central Music Co. (CME)', 'CME'), (0, 32, 100): ('genoQs Machines GmbH',), (0, 32, 101): ('Medialon',), (0, 32, 102): ('Waves Audio Ltd',), (0, 32, 103): ('Jerash Labs',), (0, 32, 104): ('Da Fact',), (0, 32, 105): ('Elby Designs',), (0, 32, 106): ('Spectral Audio',), (0, 32, 107): ('Arturia',), (0, 32, 108): ('Vixid',), (0, 32, 109): ('C-Thru Music',), (0, 32, 110): ('Ya Horng Electronic Co LTD',), (0, 32, 111): ('SM Pro Audio',), (0, 32, 112): ('OTO MACHINES',), (0, 32, 113): ('ELZAB S.A., G LAB',), (0, 32, 114): ('Blackstar Amplification Ltd', 'Blackstar'), (0, 32, 115): ('M3i Technologies GmbH',), (0, 32, 116): ('Gemalto (from Xiring)',), (0, 32, 117): ('Prostage SL',), (0, 32, 118): ('Teenage Engineering',), (0, 32, 119): ('Tobias Erichsen Consulting',), (0, 32, 120): ('Nixer Ltd',), (0, 32, 121): ('Hanpin Electron Co Ltd',), (0, 32, 122): ('"MIDI-hardware" R.Sowa',), (0, 32, 123): ('Beyond Music Industrial Ltd',), (0, 32, 124): ('Kiss Box B.V.',), (0, 32, 125): ('Misa Digital Technologies Ltd',), (0, 32, 126): ('AI Musics Technology Inc',), (0, 32, 127): ('Serato Inc LP',), (0, 33, 0): ('Limex Music Handles GmbH',), (0, 33, 1): ('Kyodday/Tokai',), (0, 33, 2): ('Mutable Instruments',), (0, 33, 3): ('PreSonus Software Ltd', 'PreSonus'), (0, 33, 4): ('Xiring',), (0, 33, 5): ('Fairlight Instruments Pty Ltd', 'Fairlight'), (0, 33, 6): ('Musicom Lab',), (0, 33, 7): ('VacoLoco',), (0, 33, 8): ('RWA (Hong Kong) Limited',), (0, 33, 9): ('Native Instruments', 'NI'), (0, 33, 10): ('Naonext',), (0, 33, 11): ('MFB',), (0, 33, 12): ('Teknel Research',), (0, 33, 13): ('Ploytec GmbH', 'Ploytec'), (0, 33, 14): ('Surfin Kangaroo Studio',), (0, 33, 15): ('Philips Electronics HK Ltd', 'Philips'), (0, 33, 16): ('ROLI Ltd',), (0, 64, 0): ('Crimson Technology Inc.',), (0, 64, 1): ('Softbank Mobile Corp',), (0, 64, 3): ('D&M Holdings Inc.',) } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/sysexsaver/models.py0000644000175000001440000002756300000000000021266 0ustar00chrisusers# -*- coding: utf-8 -*- """Map manufacturer's model ID to name.""" models = { # id: (name, shortname), 1: {}, # Sequential Circuits 4: {}, # Moog 6: {}, # Lexicon 7: {}, # Kurzweil 15: {}, # Ensoniq 16: {}, # Oberheim 17: {}, # Apple 24: {}, # Emu 26: {}, # ART 34: {}, # Synthaxe 36: {}, # Hohner 41: {}, # PPG 43: {}, # SSL 47: {}, # Elka / General Music 48: {}, # Dynacord 51: {}, # Clavia (Nord) 54: {}, # Cheetah # Waldorf Electronics GmbH 62: { 0x0E: ('microWAVE II/XT(k)', 'microwave2'), }, 64: {}, # Kawai Musical Instruments MFG. CO. Ltd 65: {}, # Roland Corporation 66: {}, # Korg Inc. 67: {}, # Yamaha Corporation 68: {}, # Casio Computer Co. Ltd 70: {}, # Kamiya Studio Co. Ltd 71: {}, # Akai Electric Co. Ltd. 72: {}, # Victor Company of Japan, Ltd. 75: {}, # Fujitsu Limited 76: {}, # Sony Corporation 78: {}, # Teac Corporation 80: {}, # Matsushita Electric Industrial Co. , Ltd 81: {}, # Fostex Corporation 82: {}, # Zoom Corporation 84: {}, # Matsushita Communication Industrial Co., Ltd. 85: {}, # Suzuki Musical Instruments MFG. Co., Ltd. 86: {}, # Fuji Sound Corporation Ltd. 87: {}, # Acoustic Technical Laboratory, Inc. 89: {}, # Faith, Inc. 90: {}, # Internet Corporation 92: {}, # Seekers Co. Ltd. 95: {}, # SD Card Association 0x7D: {}, # Non-commercial 0x7E: {}, # Universal Non-Realtime 0x7F: {}, # Universal Realtime (0, 0, 7): {}, # Digital Music Corporation (0, 0, 14): {}, # Alesis (0, 0, 21): {}, # KAT (0, 0, 22): {}, # Opcode (0, 0, 26): {}, # Allen & Heath Brenell (0, 0, 27): {}, # Peavey Electronics (0, 0, 28): {}, # 360 Systems (0, 0, 32): {}, # Axxes (0, 0, 116): {}, # Ta Horng Musical Instrument (0, 0, 117): {}, # e-Tek Labs (Forte Tech) (0, 0, 118): {}, # Electro-Voice (0, 0, 119): {}, # Midisoft Corporation (0, 0, 120): {}, # QSound Labs (0, 0, 121): {}, # Westrex (0, 0, 122): {}, # Nvidia (0, 0, 123): {}, # ESS Technology (0, 0, 124): {}, # Media Trix Peripherals (0, 0, 125): {}, # Brooktree Corp (0, 0, 126): {}, # Otari Corp (0, 0, 127): {}, # Key Electronics, Inc. (0, 1, 0): {}, # Shure Incorporated (0, 1, 1): {}, # AuraSound (0, 1, 2): {}, # Crystal Semiconductor (0, 1, 3): {}, # Conexant (Rockwell) (0, 1, 4): {}, # Silicon Graphics (0, 1, 5): {}, # M-Audio (Midiman) (0, 1, 6): {}, # PreSonus (0, 1, 8): {}, # Topaz Enterprises (0, 1, 9): {}, # Cast Lighting (0, 1, 10): {}, # Microsoft (0, 1, 11): {}, # Sonic Foundry (0, 1, 12): {}, # Line 6 (Fast Forward) (0, 1, 13): {}, # Beatnik Inc (0, 1, 14): {}, # Van Koevering Company (0, 1, 15): {}, # Altech Systems (0, 1, 16): {}, # S & S Research (0, 1, 17): {}, # VLSI Technology (0, 1, 18): {}, # Chromatic Research (0, 1, 19): {}, # Sapphire (0, 1, 20): {}, # IDRC (0, 1, 21): {}, # Justonic Tuning (0, 1, 22): {}, # TorComp Research Inc. (0, 1, 23): {}, # Newtek Inc. (0, 1, 24): {}, # Sound Sculpture (0, 1, 25): {}, # Walker Technical (0, 1, 26): {}, # Digital Harmony (PAVO) (0, 1, 27): {}, # InVision Interactive (0, 1, 28): {}, # T-Square Design (0, 1, 29): {}, # Nemesys Music Technology (0, 1, 30): {}, # DBX Professional (Harman Intl) (0, 1, 31): {}, # Syndyne Corporation (0, 1, 32): {}, # Bitheadz (0, 1, 33): {}, # Cakewalk Music Software (0, 1, 34): {}, # Analog Devices (0, 1, 35): {}, # National Semiconductor (0, 1, 36): {}, # Boom Theory / Adinolfi Alternative Percussion (0, 1, 37): {}, # Virtual DSP Corporation (0, 1, 38): {}, # Antares Systems (0, 1, 39): {}, # Angel Software (0, 1, 40): {}, # St Louis Music (0, 1, 41): {}, # Lyrrus dba G-VOX (0, 1, 42): {}, # Ashley Audio Inc. (0, 1, 43): {}, # Vari-Lite Inc. (0, 1, 44): {}, # Summit Audio Inc. (0, 1, 45): {}, # Aureal Semiconductor Inc. (0, 1, 46): {}, # SeaSound LLC (0, 1, 47): {}, # U.S. Robotics (0, 1, 48): {}, # Aurisis Research (0, 1, 49): {}, # Nearfield Research (0, 1, 50): {}, # FM7 Inc (0, 1, 51): {}, # Swivel Systems (0, 1, 52): {}, # Hyperactive Audio Systems (0, 1, 53): {}, # MidiLite (Castle Studios Productions) (0, 1, 54): {}, # Radikal Technologies (0, 1, 55): {}, # Roger Linn Design (0, 1, 56): {}, # TC-Helicon Vocal Technologies (0, 1, 57): {}, # Event Electronics (0, 1, 58): {}, # Sonic Network Inc (0, 1, 59): {}, # Realtime Music Solutions (0, 1, 60): {}, # Apogee Digital (0, 1, 61): {}, # Classical Organs, Inc. (0, 1, 62): {}, # Microtools Inc. (0, 1, 63): {}, # Numark Industries (0, 1, 64): {}, # Frontier Design Group, LLC (0, 1, 65): {}, # Recordare LLC (0, 1, 66): {}, # Starr Labs (0, 1, 67): {}, # Voyager Sound Inc. (0, 1, 68): {}, # Manifold Labs (0, 1, 69): {}, # Aviom Inc. (0, 1, 70): {}, # Mixmeister Technology (0, 1, 71): {}, # Notation Software (0, 1, 72): {}, # Mercurial Communications (0, 1, 73): {}, # Wave Arts (0, 1, 74): {}, # Logic Sequencing Devices (0, 1, 75): {}, # Axess Electronics (0, 1, 76): {}, # Muse Research (0, 1, 77): {}, # Open Labs (0, 1, 78): {}, # Guillemot R&D Inc (0, 1, 79): {}, # Samson Technologies (0, 1, 80): {}, # Electronic Theatre Controls (0, 1, 81): {}, # Blackberry (RIM) (0, 1, 82): {}, # Mobileer (0, 1, 83): {}, # Synthogy (0, 1, 84): {}, # Lynx Studio Technology Inc. (0, 1, 85): {}, # Damage Control Engineering LLC (0, 1, 86): {}, # Yost Engineering, Inc. (0, 1, 87): {}, # Brooks & Forsman Designs LLC / DrumLite (0, 1, 88): {}, # Infinite Response (0, 1, 89): {}, # Garritan Corp (0, 1, 90): {}, # Plogue Art et Technologie, Inc (0, 1, 91): {}, # RJM Music Technology (0, 1, 92): {}, # Custom Solutions Software (0, 1, 93): {}, # Sonarcana LLC (0, 1, 94): {}, # Centrance (0, 1, 95): {}, # Kesumo LLC (0, 1, 96): {}, # Stanton (Gibson) (0, 1, 97): {}, # Livid Instruments (0, 1, 98): {}, # First Act / 745 Media (0, 1, 99): {}, # Pygraphics, Inc. (0, 1, 100): {}, # Panadigm Innovations Ltd (0, 1, 101): {}, # Avedis Zildjian Co (0, 1, 102): {}, # Auvital Music Corp (0, 1, 103): {}, # Inspired Instruments Inc (0, 1, 104): {}, # Chris Grigg Designs (0, 1, 105): {}, # Slate Digital LLC (0, 1, 106): {}, # Mixware (0, 1, 107): {}, # Social Entropy (0, 1, 108): {}, # Source Audio LLC (0, 1, 109): {}, # Ernie Ball / Music Man (0, 1, 110): {}, # Fishman Transducers (0, 1, 111): {}, # Custom Audio Electronics (0, 1, 112): {}, # American Audio/DJ (0, 1, 113): {}, # Mega Control Systems (0, 1, 114): {}, # Kilpatrick Audio (0, 1, 115): {}, # iConnectivity (0, 1, 116): {}, # Fractal Audio (0, 1, 117): {}, # NetLogic Microsystems (0, 1, 118): {}, # Music Computing (0, 1, 119): {}, # Nektar Technology Inc (0, 1, 120): {}, # Zenph Sound Innovations (0, 1, 121): {}, # DJTechTools.com (0, 1, 122): {}, # Rezonance Labs (0, 1, 123): {}, # Decibel Eleven (0, 1, 124): {}, # CNMAT (0, 1, 125): {}, # Media Overkill (0, 1, 126): {}, # Confusionists LLC (0, 32, 39): {}, # Acorn Computer (0, 32, 41): {}, # Focusrite/Novation (0, 32, 42): {}, # Samkyung Mechatronics (0, 32, 43): {}, # Medeli Electronics Co. (0, 32, 44): {}, # Charlie Lab SRL (0, 32, 45): {}, # Blue Chip Music Technology (0, 32, 46): {}, # BEE OH Corp (0, 32, 47): {}, # LG Semicon America (0, 32, 48): {}, # TESI (0, 32, 49): {}, # EMAGIC (0, 32, 50): {}, # Behringer GmbH (0, 32, 51): {}, # Access Music Electronics (0, 32, 52): {}, # Synoptic (0, 32, 53): {}, # Hanmesoft (0, 32, 54): {}, # Terratec Electronic GmbH (0, 32, 55): {}, # Proel SpA (0, 32, 56): {}, # IBK MIDI (0, 32, 57): {}, # IRCAM (0, 32, 58): {}, # Propellerhead Software (0, 32, 59): {}, # Red Sound Systems Ltd (0, 32, 60): {}, # Elektron ESI AB (0, 32, 61): {}, # Sintefex Audio (0, 32, 62): {}, # MAM (Music and More) (0, 32, 63): {}, # Amsaro GmbH (0, 32, 64): {}, # CDS Advanced Technology BV (0, 32, 65): {}, # Touched By Sound GmbH (0, 32, 66): {}, # DSP Arts (0, 32, 67): {}, # Phil Rees Music Tech (0, 32, 68): {}, # Stamer Musikanlagen GmbH (0, 32, 69): {}, # Musical Muntaner S.A. dba Soundart (0, 32, 70): {}, # C-Mexx Software (0, 32, 71): {}, # Klavis Technologies (0, 32, 72): {}, # Noteheads AB (0, 32, 73): {}, # Algorithmix (0, 32, 74): {}, # Skrydstrup R&D (0, 32, 75): {}, # Professional Audio Company (0, 32, 76): {}, # NewWave Labs (MadWaves) (0, 32, 77): {}, # Vermona (0, 32, 78): {}, # Nokia (0, 32, 79): {}, # Wave Idea (0, 32, 80): {}, # Hartmann GmbH (0, 32, 81): {}, # Lion's Tracs (0, 32, 82): {}, # Analogue Systems (0, 32, 83): {}, # Focal-JMlab (0, 32, 84): {}, # Ringway Electronics (Chang-Zhou) Co Ltd (0, 32, 85): {}, # Faith Technologies (Digiplug) (0, 32, 86): {}, # Showworks (0, 32, 87): {}, # Manikin Electronic (0, 32, 88): {}, # 1 Come Tech (0, 32, 89): {}, # Phonic Corp (0, 32, 90): {}, # Dolby Australia (Lake) (0, 32, 91): {}, # Silansys Technologies (0, 32, 92): {}, # Winbond Electronics (0, 32, 93): {}, # Cinetix Medien und Interface GmbH (0, 32, 94): {}, # A&G Soluzioni Digitali (0, 32, 95): {}, # Sequentix Music Systems (0, 32, 96): {}, # Oram Pro Audio (0, 32, 97): {}, # Be4 Ltd (0, 32, 98): {}, # Infection Music (0, 32, 99): {}, # Central Music Co. (CME) (0, 32, 100): {}, # genoQs Machines GmbH (0, 32, 101): {}, # Medialon (0, 32, 102): {}, # Waves Audio Ltd (0, 32, 103): {}, # Jerash Labs (0, 32, 104): {}, # Da Fact (0, 32, 105): {}, # Elby Designs (0, 32, 106): {}, # Spectral Audio (0, 32, 107): {}, # Arturia (0, 32, 108): {}, # Vixid (0, 32, 109): {}, # C-Thru Music (0, 32, 110): {}, # Ya Horng Electronic Co LTD (0, 32, 111): {}, # SM Pro Audio (0, 32, 112): {}, # OTO MACHINES (0, 32, 113): {}, # ELZAB S.A., G LAB (0, 32, 114): {}, # Blackstar Amplification Ltd (0, 32, 115): {}, # M3i Technologies GmbH (0, 32, 116): {}, # Gemalto (from Xiring) (0, 32, 117): {}, # Prostage SL (0, 32, 118): {}, # Teenage Engineering (0, 32, 119): {}, # Tobias Erichsen Consulting (0, 32, 120): {}, # Nixer Ltd (0, 32, 121): {}, # Hanpin Electron Co Ltd (0, 32, 122): {}, # "MIDI-hardware" R.Sowa (0, 32, 123): {}, # Beyond Music Industrial Ltd (0, 32, 124): {}, # Kiss Box B.V. (0, 32, 125): {}, # Misa Digital Technologies Ltd (0, 32, 126): {}, # AI Musics Technology Inc (0, 32, 127): {}, # Serato Inc LP (0, 33, 0): {}, # Limex Music Handles GmbH (0, 33, 1): {}, # Kyodday/Tokai (0, 33, 2): { 0x02: ("Shruthi-1", "shruthi-1"), }, # Mutable Instruments (0, 33, 3): {}, # PreSonus Software Ltd (0, 33, 4): {}, # Xiring (0, 33, 5): {}, # Fairlight Instruments Pty Ltd (0, 33, 6): {}, # Musicom Lab (0, 33, 7): {}, # VacoLoco (0, 33, 8): {}, # RWA (Hong Kong) Limited (0, 33, 9): {}, # Native Instruments (0, 33, 10): {}, # Naonext (0, 33, 11): {}, # MFB (0, 33, 12): {}, # Teknel Research (0, 33, 13): {}, # Ploytec GmbH (0, 33, 14): {}, # Surfin Kangaroo Studio (0, 33, 15): {}, # Philips Electronics HK Ltd (0, 33, 16): {}, # ROLI Ltd (0, 64, 0): {}, # Crimson Technology Inc. (0, 64, 1): {}, # Softbank Mobile Corp (0, 64, 3): {}, # D&M Holdings Inc. } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/examples/wavetablemodstep.py0000644000175000001440000000625700000000000021132 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- # # wavetablemodstep.py # """Play a note and step through MIDI Control Change #1 (modulation) values. Optionally allows to send a Control Change #70 first, to set the wavetable of the current sound on a Waldorf Microwave II/XT(k) synthesizer. I use this with a Microwave sound program where the CC #1 is mapped to wavetable position of oscillator 1. This script then allows me to listen to all the waves in a selected wavetable in succession. """ import time import rtmidi from rtmidi.midiconstants import (CONTROL_CHANGE, MODULATION_WHEEL, NOTE_OFF, NOTE_ON, RESET_ALL_CONTROLLERS) CC_SET_WAVETABLE = 70 class Midi(object): """Encapsulate MIDI output.""" def __init__(self, port): self.midi = rtmidi.MidiOut() self.midi.open_port(port) def play_stepping(self, note, cc, dur=0.2, step=1, vel=64, rvel=None, ch=0): """Play given note and step through ctrl values over time.""" # note on note &= 0x7F ch &= 0x0F self.midi.send_message([CONTROL_CHANGE | ch, cc, 0]) time.sleep(0.1) self.midi.send_message([NOTE_ON | ch, note, vel & 0x7F]) # step through modulation controller values for i in range(0, 128, step): self.midi.send_message([CONTROL_CHANGE | ch, cc, i]) time.sleep(dur) # note off self.midi.send_message( [NOTE_OFF | ch, note, (vel if rvel is None else rvel) & 0x7F]) def reset_controllers(self, ch=0): """Reset controllers on given channel.""" self.midi.send_message( [CONTROL_CHANGE | (ch & 0xF), RESET_ALL_CONTROLLERS, 0]) def set_wavetable(self, wt, ch=0): """Set wavetable for current sound to given number.""" self.midi.send_message( [CONTROL_CHANGE | (ch & 0xF), CC_SET_WAVETABLE, wt & 0x7F]) def close(self): """Close MIDI outpurt.""" self.midi.close_port() del self.midi if __name__ == '__main__': import argparse argparser = argparse.ArgumentParser() aadd = argparser.add_argument aadd('-c', '--channel', type=int, default=1, help="MIDI channel (1-based, default: %(default)s)") aadd('-C', '--controller', type=int, default=MODULATION_WHEEL, help="MIDI controller number (default: %(default)s)") aadd('-p', '--port', type=int, default=0, help="MIDI output port (default: %(default)s)") aadd('-l', '--length', type=float, default=0.3, help="Length (in sec.) of each wave (default: %(default)s)") aadd('-n', '--note', type=int, default=60, help="MIDI note number to play (default: %(default)s)") aadd('-w', '--wavetable', type=int, help="Send CC #70 to set wavetable number (1-based, default: none)") args = argparser.parse_args() m = Midi(args.port) ch = max(0, args.channel - 1) if args.wavetable: m.set_wavetable(args.wavetable - 1, ch=args.channel - 1) time.sleep(0.1) try: m.reset_controllers(ch) m.play_stepping(args.note, args.controller, dur=args.length, step=2, ch=ch) finally: m.reset_controllers(ch) m.close() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/fill_template.py0000755000175000001440000000433200000000000016562 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Custom distutils command to fill placeholders in text files with release meta-data. """ from os.path import join from string import Template try: basestring # noqa except: basestring = str from distutils.core import Command from distutils.dist import DistributionMetadata from distutils.log import error, info from distutils.util import split_quoted DistributionMetadata.templates = None class FillTemplate(Command): """Custom distutils command to fill text templates with release meta data. """ description = "Fill placeholders in documentation text file templates" user_options = [ ('templates=', None, "Template text files to fill") ] def initialize_options(self): self.templates = '' self.template_ext = '.in' def finalize_options(self): if isinstance(self.templates, basestring): self.templates = split_quoted(self.templates) self.templates += getattr(self.distribution.metadata, 'templates', None) or [] for tmpl in self.templates: if not tmpl.endswith(self.template_ext): raise ValueError("Template file '%s' does not have expected " "extension '%s'." % (tmpl, self.template_ext)) def run(self): metadata = self.get_metadata() for infilename in self.templates: try: info("Reading template '%s'...", infilename) with open(infilename) as infile: tmpl = Template(infile.read()) outfilename = infilename.rstrip(self.template_ext) info("Writing filled template to '%s'.", outfilename) with open(outfilename, 'w') as outfile: outfile.write(tmpl.safe_substitute(metadata)) except: error("Could not open template '%s'.", infilename) def get_metadata(self): data = dict() for attr in self.distribution.metadata.__dict__: if not callable(attr): data[attr] = getattr(self.distribution.metadata, attr) data['cpp_info'] = open(join("src", '_rtmidi.cpp')).readline().strip() return data ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2504177 python-rtmidi-1.4.7/python_rtmidi.egg-info/0000755000175000001440000000000000000000000017745 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/python_rtmidi.egg-info/PKG-INFO0000644000175000001440000001237000000000000021045 0ustar00chrisusersMetadata-Version: 1.1 Name: python-rtmidi Version: 1.4.7 Summary: A Python binding for the RtMidi C++ library implemented using Cython. Home-page: https://github.com/SpotlightKid/python-rtmidi Author: Christopher Arndt Author-email: chris@chrisarndt.de License: MIT License Download-URL: https://pypi.python.org/pypi/python-rtmidi Description: Welcome to python-rtmidi! ========================= A Python binding for the RtMidi C++ library implemented using Cython. |version| |status| |license| |python_versions| |format| |travis| .. |version| image:: https://shields.io/pypi/v/python-rtmidi :target: https://pypi.org/project/python-rtmidi :alt: Latest version .. |release-date| image:: https://shields.io/github/release-date/SpotlightKid/python-rtmidi :target: https://github.com/SpotlightKid/python-rtmidi/releases :alt: Date of latest release .. |status| image:: https://shields.io/pypi/status/python-rtmidi :alt: Project status .. |license| image:: https://shields.io/pypi/l/python-rtmidi :target: license.txt_ :alt: MIT License .. |python_versions| image:: https://shields.io/pypi/pyversions/python-rtmidi :alt: Python versions .. |format| image:: https://shields.io/pypi/format/python-rtmidi :target: https://pypi.org/project/python-rtmidi/#files :alt: Distribution format .. |travis| image:: https://travis-ci.org/SpotlightKid/python-rtmidi.svg?branch=master :target: https://travis-ci.org/SpotlightKid/python-rtmidi :alt: Travis CI status Overview ======== RtMidi_ is a set of C++ classes which provides a concise and simple, cross-platform API (Application Programming Interface) for realtime MIDI input / output across Linux (ALSA & JACK), macOS / OS X (CoreMIDI & JACK), and Windows (MultiMedia System) operating systems. python-rtmidi_ is a Python binding for RtMidi implemented using Cython_ and provides a thin wrapper around the RtMidi C++ interface. The API is basically the same as the C++ one but with the naming scheme of classes, methods and parameters adapted to the Python PEP-8 conventions and requirements of the Python package naming structure. **python-rtmidi** supports Python 3 (3.6, 3.7, 3.8, and 3.9). The documentation_ provides installation instructions, a history of changes per release and an API reference. See the file `LICENSE.txt`_ about copyright and usage terms. The source code repository and issue tracker are hosted on GitHub: https://github.com/SpotlightKid/python-rtmidi. Usage example ------------- Here's a quick example of how to use **python-rtmidi** to open the first available MIDI output port and send a middle C note on MIDI channel 1:: import time import rtmidi midiout = rtmidi.MidiOut() available_ports = midiout.get_ports() if available_ports: midiout.open_port(0) else: midiout.open_virtual_port("My virtual output") with midiout: note_on = [0x90, 60, 112] # channel 1, middle C, velocity 112 note_off = [0x80, 60, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout More usage examples can be found in the examples_ and tests_ directories of the source repository. .. _cython: http://cython.org/ .. _documentation: https://spotlightkid.github.io/python-rtmidi/ .. _examples: https://github.com/SpotlightKid/python-rtmidi/tree/master/examples .. _license.txt: https://github.com/SpotlightKid/python-rtmidi/blob/master/LICENSE.txt .. _python-rtmidi: https://github.com/SpotlightKid/python-rtmidi .. _rtmidi: http://www.music.mcgill.ca/~gary/rtmidi/index.html .. _tests: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests Keywords: midi,music,rtmidi Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: MacOS X Classifier: Environment :: Win32 (MS Windows) Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI Classifier: Topic :: Software Development :: Libraries :: Python Modules ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/python_rtmidi.egg-info/SOURCES.txt0000644000175000001440000000453500000000000021640 0ustar00chrisusers.gitignore .gitmodules AUTHORS.rst CHANGELOG.rst INSTALL-windows.rst INSTALL.rst LICENSE.txt MANIFEST.in Makefile README.rst deploy.sh fill_template.py requirements-dev.txt setup.cfg setup.py tox.ini update-docs.sh docs/Makefile docs/api.rst.inc docs/authors.rst docs/conf.py docs/contributing.rst docs/history.rst docs/index.rst docs/install-windows.rst docs/installation.rst docs/license.rst docs/make.bat docs/modules.rst docs/rtmidi.rst docs/usage.rst examples/sendsysex.py examples/wavetablemodstep.py examples/advanced/ccstore.py examples/advanced/midiclock.py examples/advanced/midioutwrapper.py examples/advanced/recvrpn.py examples/basic/contextmanager.py examples/basic/midiin_callback.py examples/basic/midiin_poll.py examples/basic/midiout.py examples/basic/noteon2osc.py examples/basic/panic.py examples/basic/probe_ports.py examples/drumseq/README.rst examples/drumseq/break-on-through.txt examples/drumseq/drumseq.py examples/drumseq/example_01.txt examples/drumseq/example_02.txt examples/drumseq/example_03.txt examples/drumseq/example_04.txt examples/drumseq/example_05.txt examples/drumseq/example_06.txt examples/drumseq/example_07.txt examples/drumseq/example_08.txt examples/drumseq/example_09.txt examples/drumseq/example_10.txt examples/drumseq/example_11.txt examples/drumseq/example_12.txt examples/drumseq/funkydrummer.txt examples/drumseq/rosanna-shuffle.txt examples/drumseq/template.txt examples/midi2command/000-playback.mp3 examples/midi2command/000-sheet.pdf examples/midi2command/README.rst examples/midi2command/example.cfg examples/midi2command/midi2command.py examples/midifilter/__init__.py examples/midifilter/__main__.py examples/midifilter/filters.py examples/sequencer/sequencer.py examples/sysex/send_sysex.py examples/sysex/send_sysex_file.py examples/sysexsaver/__init__.py examples/sysexsaver/__main__.py examples/sysexsaver/manufacturers.csv examples/sysexsaver/manufacturers.py examples/sysexsaver/models.py python_rtmidi.egg-info/PKG-INFO python_rtmidi.egg-info/SOURCES.txt python_rtmidi.egg-info/dependency_links.txt python_rtmidi.egg-info/not-zip-safe python_rtmidi.egg-info/top_level.txt rtmidi/__init__.py rtmidi/midiconstants.py rtmidi/midiutil.py rtmidi/version.py src/_rtmidi.cpp src/_rtmidi.pyx src/pyinit.h src/rtmidi/RtMidi.cpp src/rtmidi/RtMidi.h tests/test_delete.py tests/test_errorcallback.py tests/test_errors.py tests/test_rtmidi.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/python_rtmidi.egg-info/dependency_links.txt0000644000175000001440000000000100000000000024013 0ustar00chrisusers ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/python_rtmidi.egg-info/not-zip-safe0000644000175000001440000000000100000000000022173 0ustar00chrisusers ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/python_rtmidi.egg-info/top_level.txt0000644000175000001440000000000700000000000022474 0ustar00chrisusersrtmidi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/requirements-dev.txt0000644000175000001440000000153600000000000017427 0ustar00chrisusersalabaster==0.7.12 appdirs==1.4.4 atomicwrites==1.4.0 attrs==20.2.0 Babel==2.8.0 certifi==2020.6.20 chardet==3.0.4 coverage==5.3 Cython==0.29.21 distlib==0.3.1 docutils==0.16 filelock==3.0.12 flake8==3.8.4 idna==2.8 imagesize==1.2.0 iniconfig==1.0.1 Jinja2==2.11.2 MarkupSafe==1.1.1 mccabe==0.6.1 mock==4.0.2 more-itertools==8.5.0 packaging==20.4 pbr==5.5.0 pluggy==0.13.1 py==1.9.0 pycodestyle==2.6.0 pydocstyle==5.1.1 pyflakes==2.2.0 Pygments==2.7.1 pyparsing==2.4.7 pytest==6.1.1 pytz==2020.1 requests==2.24.0 six==1.15.0 snowballstemmer==2.0.0 Sphinx==3.2.1 sphinxcontrib-applehelp==1.0.2 sphinxcontrib-devhelp==1.0.2 sphinxcontrib-htmlhelp==1.0.3 sphinxcontrib-jsmath==1.0.1 sphinxcontrib-qthelp==1.0.3 sphinxcontrib-serializinghtml==1.1.4 sphinxcontrib-websupport==1.2.4 sphinx-rtd-theme==0.5.0 toml==0.10.1 tox==3.20.0 urllib3==1.25.10 virtualenv==20.0.33 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2504177 python-rtmidi-1.4.7/rtmidi/0000755000175000001440000000000000000000000014652 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/rtmidi/__init__.py0000644000175000001440000000031200000000000016757 0ustar00chrisusers# -*- coding:utf-8 -*- from __future__ import absolute_import from .version import version as __version__ # noqa from ._rtmidi import * # noqa from ._rtmidi import __doc__ # noqa del absolute_import ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/rtmidi/midiconstants.py0000644000175000001440000001655500000000000020117 0ustar00chrisusers# -*- coding: utf-8 -*- """Definitions of midi events, controller numbers and parameters.""" ################################################### # Midi channel events (the most common events) # Also called "Channel Voice Messages" NOTE_OFF = 0x80 # 1000cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity) NOTE_ON = 0x90 # 1001cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity) POLY_AFTERTOUCH = POLYPHONIC_PRESSURE = POLY_PRESSURE = 0xA0 # 1010cccc 0nnnnnnn 0vvvvvvv (channel, note, velocity) # see Channel Mode Messages for Controller Numbers CONTROLLER_CHANGE = CONTROL_CHANGE = 0xB0 # 1011cccc 0ccccccc 0vvvvvvv (channel, controller, value) PROGRAM_CHANGE = 0xC0 # 1100cccc 0ppppppp (channel, program) CHANNEL_AFTERTOUCH = CHANNEL_PRESSURE = MONO_PRESSURE = 0xD0 # 1101cccc 0ppppppp (channel, pressure) PITCH_BEND = 0xE0 # 1110cccc 0vvvvvvv 0wwwwwww (channel, value-lo, value-hi) ################################################### # Channel Mode Messages (Continuous Controller) # All CCs have the same status byte (0xBn). # The controller number is the first data byte # High resolution continuous controllers (MSB) BANK_SELECT = BANK_SELECT_MSB = 0x00 MODULATION = MODULATION_WHEEL = MODULATION_WHEEL_MSB = 0x01 BREATH_CONTROLLER = BREATH_CONTROLLER_MSB = 0x02 FOOT_CONTROLLER = FOOT_CONTROLLER_MSB = 0x04 PORTAMENTO_TIME = PORTAMENTO_TIME_MSB = 0x05 DATA_ENTRY = DATA_ENTRY_MSB = 0x06 VOLUME = CHANNEL_VOLUME = CHANNEL_VOLUME_MSB = 0x07 BALANCE = BALANCE_MSB = 0x08 PAN = PAN_MSB = 0x0A EXPRESSION = EXPRESSION_CONTROLLER = EXPRESSION_CONTROLLER_MSB = 0x0B EFFECT_CONTROL_1 = EFFECT_CONTROL_1_MSB = 0x0C EFFECT_CONTROL_2 = EFFECT_CONTROL_2_MSB = 0x0D GENERAL_PURPOSE_CONTROLLER_1 = GENERAL_PURPOSE_CONTROLLER_1_MSB = 0x10 GENERAL_PURPOSE_CONTROLLER_2 = GENERAL_PURPOSE_CONTROLLER_2_MSB = 0x11 GENERAL_PURPOSE_CONTROLLER_3 = GENERAL_PURPOSE_CONTROLLER_3_MSB = 0x12 GENERAL_PURPOSE_CONTROLLER_4 = GENERAL_PURPOSE_CONTROLLER_4_MSB = 0x13 # High resolution continuous controllers (LSB) BANK_SELECT_LSB = 0x20 MODULATION_LSB = MODULATION_WHEEL_LSB = 0x21 BREATH_CONTROLLER_LSB = 0x22 FOOT_CONTROLLER_LSB = 0x24 PORTAMENTO_TIME_LSB = 0x25 DATA_ENTRY_LSB = 0x26 VOLUME_LSB = CHANNEL_VOLUME_LSB = 0x27 BALANCE_LSB = 0x28 PAN_LSB = 0x2A EXPRESSION_LSB = EXPRESSION_CONTROLLER_LSB = 0x2B EFFECT_CONTROL_1_LSB = 0x2C EFFECT_CONTROL_2_LSB = 0x2D GENERAL_PURPOSE_CONTROLLER_1_LSB = 0x30 GENERAL_PURPOSE_CONTROLLER_2_LSB = 0x31 GENERAL_PURPOSE_CONTROLLER_3_LSB = 0x32 GENERAL_PURPOSE_CONTROLLER_4_LSB = 0x33 # Switches # off: value <= 63, on: value >= 64 SUSTAIN = SUSTAIN_ONOFF = 0x40 PORTAMENTO = PORTAMENTO_ONOFF = 0x41 SOSTENUTO = SOSTENUTO_ONOFF = 0x42 SOFT_PEDAL = SOFT_PEDAL_ONOFF = 0x43 LEGATO = LEGATO_ONOFF = 0x44 HOLD_2 = HOLD_2_ONOFF = 0x45 # Low resolution continuous controllers # Sound Variation; FX: Exciter On/Off SOUND_CONTROLLER_1 = 0x46 # Harmonic Content; FX: Compressor On/Off SOUND_CONTROLLER_2 = 0x47 # Release Time; FX: Distortion On/Off SOUND_CONTROLLER_3 = 0x48 # Attack Time; FX: EQ On/Off SOUND_CONTROLLER_4 = 0x49 # Brightness; FX: Expander On/Off SOUND_CONTROLLER_5 = 0x4A # Decay Time; FX: Reverb On/Off SOUND_CONTROLLER_6 = 0x4B # Vibrato Rate; FX: Delay On/Off SOUND_CONTROLLER_7 = 0x4C # Vibrato Depth; FX: Pitch Transpose On/Off SOUND_CONTROLLER_8 = 0x4D # Vibrato Delay; FX: Flange/Chorus On/Off SOUND_CONTROLLER_9 = 0x4E # Undefined; FX: Special Effects On/Off SOUND_CONTROLLER_10 = 0x4F GENERAL_PURPOSE_CONTROLLER_5 = 0x50 GENERAL_PURPOSE_CONTROLLER_6 = 0x51 GENERAL_PURPOSE_CONTROLLER_7 = 0x52 GENERAL_PURPOSE_CONTROLLER_8 = 0x53 # PTC, 0vvvvvvv is the source Note number PORTAMENTO_CONTROL = PTC = 0x54 HIGH_RESOLUTION_VELOCITY_PREFIX = 0x58 # Reverb Send Level, formerly Ext. Effects Depth EFFECTS_1 = EFFECTS_1_DEPTH = 0x5B # formerly Tremelo Depth EFFECTS_2 = EFFECTS_2_DEPTH = 0x5C # Chorus Send Level, formerly Chorus Depth EFFECTS_3 = EFFECTS_3_DEPTH = 0x5D # formerly Celeste(Detune) Depth EFFECTS_4 = EFFECTS_4_DEPTH = 0x5E # formerly Phaser Depth EFFECTS_5 = EFFECTS_5_DEPTH = 0x5F # controller value byte should be 0 DATA_INCREMENT = 0x60 # controller value byte should be 0 DATA_DECREMENT = 0x61 NRPN_LSB = NON_REGISTERED_PARAMETER_NUMBER_LSB = 0x62 NRPN_MSB = NON_REGISTERED_PARAMETER_NUMBER_MSB = 0x63 RPN_LSB = REGISTERED_PARAMETER_NUMBER_LSB = 0x64 RPN_MSB = REGISTERED_PARAMETER_NUMBER_MSB = 0x65 # Channel Mode messages # controller value byte should be 0 ALL_SOUND_OFF = 0x78 # controller value byte should be 0 RESET_ALL_CONTROLLERS = 0x79 # 0 = off, 127 = on LOCAL_CONTROL = LOCAL_CONTROL_ONOFF = 0x7A # controller value byte should be 0 ALL_NOTES_OFF = 0x7B # controller value byte should be 0, also causes ANO OMNI_MODE_OFF = 0x7C # controller value byte should be 0, also causes ANO OMNI_MODE_ON = 0x7D # Mono Mode on / Poly Off; also causes ANO # 1011nnnn 01111110 0000vvvv # vvvv > 0 : Number of channels to use (Omni Off). # vvvv = 0 : Use all available channels (Omni On) MONO_MODE_ON = 0x7E # Poly Mode On / Mono Off # controller value byte should be 0, also causes ANO POLY_MODE_ON = 0x7F ################################################### # System Common Messages, for all channels # 11110000 0iiiiiii 0ddddddd ... 11110111 SYSTEM_EXCLUSIVE = 0xF0 # MIDI Time Code Quarter Frame # 11110001 MIDI_TIME_CODE = MTC = 0xF1 # 11110010 0vvvvvvv 0wwwwwww (lo-position, hi-position) SONG_POSITION_POINTER = 0xF2 # 11110011 0sssssss (songnumber) SONG_SELECT = 0xF3 # 11110100 (0xF4) is undefined # 11110101 (0xF5) is undefined # 11110110 TUNING_REQUEST = TUNE_REQUEST = 0xF6 # 11110111 # End of system exclusive END_OF_EXCLUSIVE = 0xF7 ################################################### # Midifile meta-events SEQUENCE_NUMBER = 0x00 # 00 02 ss ss (seq-number) TEXT = 0x01 # 01 len text... COPYRIGHT = 0x02 # 02 len text... SEQUENCE_NAME = 0x03 # 03 len text... INSTRUMENT_NAME = 0x04 # 04 len text... LYRIC = 0x05 # 05 len text... MARKER = 0x06 # 06 len text... CUEPOINT = 0x07 # 07 len text... PROGRAM_NAME = 0x08 # 08 len text... DEVICE_NAME = 0x09 # 09 len text... MIDI_CH_PREFIX = 0x20 # MIDI channel prefix assignment (deprecated) MIDI_PORT = 0x21 # 21 01 port, deprecated but still used END_OF_TRACK = 0x2F # 2f 00 TEMPO = 0x51 # 51 03 tt tt tt (tempo in µs/quarternote) SMTP_OFFSET = 0x54 # 54 05 hh mm ss ff xx TIME_SIGNATURE = 0x58 # 58 04 nn dd cc bb KEY_SIGNATURE = 0x59 # 59 02 sf mi (sf = number of sharps(+) or flats(-) # mi = major(0) or minor (1)) SPECIFIC = 0x7F # Sequencer specific event ################################################### # System Realtime messages # These should not occur in midi files TIMING_CLOCK = 0xF8 # 0xF9 is undefined SONG_START = 0xFA SONG_CONTINUE = 0xFB SONG_STOP = 0xFC # 0xFD is undefined ACTIVE_SENSING = 0xFE SYSTEM_RESET = 0xFF ################################################### # META EVENT, it is used only in midi files. # In transmitted data it means system reset!!! # 11111111 META_EVENT = 0xFF ESCAPE_SEQUENCE = 0xF7 ################################################### # Misc constants FILE_HEADER = 'MThd' TRACK_HEADER = 'MTrk' # Timecode resolution: frames per second FPS_24 = 0xE8 FPS_25 = 0xE7 FPS_29 = 0xE3 FPS_30 = 0xE2 ################################################### # Helper functions def is_status(byte): """Return True if the given byte is a MIDI status byte, False otherwise.""" return (byte & 0x80) == 0x80 # 1000 0000 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/rtmidi/midiutil.py0000644000175000001440000002170600000000000017052 0ustar00chrisusers# -*- coding: utf-8 -*- # # midiutil.py # """Collection of utility functions for handling MIDI I/O and ports. Currently contains functions to list MIDI input/output ports, to get the RtMidi API to use from the environment and to open MIDI ports. """ from __future__ import print_function, unicode_literals import logging import os try: raw_input except NameError: # Python 3 raw_input = input basestring = str import rtmidi __all__ = ( 'get_api_from_environment', 'list_available_ports', 'list_input_ports', 'list_output_ports', 'open_midiinput', 'open_midioutput', 'open_midiport', ) log = logging.getLogger(__name__) def _prompt_for_virtual(type_): """Prompt on the console whether a virtual MIDI port should be opened.""" return raw_input("Do you want to create a virtual MIDI %s port? (y/N) " % type_).strip().lower() in ['y', 'yes'] def get_api_from_environment(api=rtmidi.API_UNSPECIFIED): """Return RtMidi API specified in the environment if any. If the optional api argument is ``rtmidi.API_UNSPECIFIED`` (the default), look in the environment variable ``RTMIDI_API`` for the name of the RtMidi API to use. Valid names are ``LINUX_ALSA``, ``UNIX_JACK``, ``MACOSX_CORE``, ``WINDOWS_MM`` and ``RTMIDI_DUMMY``. If no valid value is found, ``rtmidi.API_UNSPECIFIED`` will be used. Returns a ``rtmidi.API_*`` constant. """ if api == rtmidi.API_UNSPECIFIED and 'RTMIDI_API' in os.environ: try: api_name = os.environ['RTMIDI_API'].upper() api = getattr(rtmidi, 'API_' + api_name) except AttributeError: log.warning("Ignoring unknown API '%s' in environment variable " "RTMIDI_API." % api_name) return api def list_available_ports(ports=None, midiio=None): """List MIDI ports given or available on given MIDI I/O instance.""" if ports is None: ports = midiio.get_ports() type_ = " input" if isinstance(midiio, rtmidi.MidiIn) else " ouput" else: type_ = '' if ports: print("Available MIDI{} ports:\n".format(type_)) for portno, name in enumerate(ports): print("[{}] {}".format(portno, name)) else: print("No MIDI{} ports found.".format(type_)) print() def list_input_ports(api=rtmidi.API_UNSPECIFIED): """List available MIDI input ports. Optionally the RtMidi API can be passed with the ``api`` argument. If not it will be determined via the ``get_api_from_environment`` function. Exceptions: ``rtmidi.SystemError`` Raised when RtMidi backend initialization fails. """ midiin = rtmidi.MidiIn(get_api_from_environment(api)) list_available_ports(midiio=midiin) def list_output_ports(api=rtmidi.API_UNSPECIFIED): """List available MIDI output ports. Optionally the RtMidi API can be passed with the ``api`` argument. If not it will be determined via the ``get_api_from_environment`` function. Exceptions: ``rtmidi.SystemError`` Raised when RtMidi backend initialization fails. """ midiout = rtmidi.MidiOut(get_api_from_environment(api)) list_available_ports(midiio=midiout) def open_midiport(port=None, type_="input", api=rtmidi.API_UNSPECIFIED, use_virtual=False, interactive=True, client_name=None, port_name=None): """Open MIDI port for input or output and return MidiIn/MidiOut instance. Arguments: ``port`` A MIDI port number or (substring of) a port name or ``None``. Available ports are enumerated starting from zero separately for input and output ports. If only a substring of a port name is given, the first matching port is used. ``type_`` Must be ``"input"`` or ``"output"``. Determines whether a ``MidiIn`` or ``MidiOut`` instance will be created and returned. ``api`` Select the low-level MIDI API to use. Defaults to ``API_UNSPECIFIED``, The specified api will be passed to the ``get_api_from_environment`` function and its return value will be used. If it's ``API_UNSPECIFIED`` the first compiled-in API, which has any input resp. output ports available, will be used. ``use_virtual`` If ``port`` is ``None``, should a virtual MIDI port be opened? Defaults to ``False``. ``interactive`` If ``port`` is ``None`` or no MIDI port matching the port number or name is available, should the user be prompted on the console whether to open a virtual MIDI port (if ``use_virtual`` is ``True``) and/or with a list of available MIDI ports and the option to choose one? Defaults to ``True``. ``client_name`` The name of the MIDI client passed when instantiating a ``MidiIn`` or ``MidiOut`` object. See the documentation of the constructor for these classes for the default values and caveats and OS-dependent ideosyncracies regarding the client name. ``port_name`` The name of the MIDI port passed to the ``open_port`` or ``open_virtual_port`` method of the new ``MidiIn`` or ``MidiOut`` instance. See the documentation of the ``open_port`` resp. ``open_virtual_port`` methods for the default values and caveats when wanting to change the port name afterwards. Returns: A two-element tuple of a new ``MidiIn`` or ``MidiOut`` instance and the name of the MIDI port which was opened. Exceptions: ``KeyboardInterrupt, EOFError`` Raised when the user presses Control-C or Control-D during a console prompt. ``rtmidi.SystemError`` Raised when RtMidi backend initialization fails. ``rtmidi.NoDevicesError`` Raised when no MIDI input or output ports (depending on what was requested) are available. ``rtmidi.InvalidPortError`` Raised when an invalid port number or name is passed and ``interactive`` is ``False``. """ midiclass_ = rtmidi.MidiIn if type_ == "input" else rtmidi.MidiOut log.debug("Creating %s object.", midiclass_.__name__) api = get_api_from_environment(api) midiobj = midiclass_(api, name=client_name) type_ = "input" if isinstance(midiobj, rtmidi.MidiIn) else "output" ports = midiobj.get_ports() if port is None: try: if (midiobj.get_current_api() != rtmidi.API_WINDOWS_MM and (use_virtual or (interactive and _prompt_for_virtual(type_)))): if not port_name: port_name = "Virtual MIDI %s" % type_ log.info("Opening virtual MIDI %s port.", type_) midiobj.open_virtual_port(port_name) return midiobj, port_name except (KeyboardInterrupt, EOFError): del midiobj print('') raise if len(ports) == 0: del midiobj raise rtmidi.NoDevicesError("No MIDI %s ports found." % type_) try: port = int(port) except (TypeError, ValueError): if isinstance(port, basestring): portspec = port for portno, name in enumerate(ports): if portspec in name: port = portno break else: log.warning("No port matching '%s' found.", portspec) port = None while interactive and (port is None or (port < 0 or port >= len(ports))): list_available_ports(ports) try: r = raw_input("Select MIDI %s port (Control-C to exit): " % type_) port = int(r) except (KeyboardInterrupt, EOFError): del midiobj print('') raise except (ValueError, TypeError): port = None if port is not None and (port >= 0 and port < len(ports)): if not port_name: port_name = ports[port] log.info("Opening MIDI %s port #%i (%s)." % (type_, port, port_name)) midiobj.open_port(port, port_name) return midiobj, port_name else: raise rtmidi.InvalidPortError("Invalid port.") def open_midiinput(port=None, api=rtmidi.API_UNSPECIFIED, use_virtual=False, interactive=True, client_name=None, port_name=None): """Open a MIDI port for input and return a MidiIn instance. See the ``open_midiport`` function for information on parameters and possible exceptions. """ return open_midiport(port, "input", api, use_virtual, interactive, client_name, port_name) def open_midioutput(port=None, api=rtmidi.API_UNSPECIFIED, use_virtual=False, interactive=True, client_name=None, port_name=None): """Open a MIDI port for output and return a MidiOut instance. See the ``open_midiport`` function for information on parameters and possible exceptions. """ return open_midiport(port, "output", api, use_virtual, interactive, client_name, port_name) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611759348.0 python-rtmidi-1.4.7/rtmidi/version.py0000644000175000001440000000002200000000000016703 0ustar00chrisusersversion = '1.4.7' ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2544177 python-rtmidi-1.4.7/setup.cfg0000644000175000001440000000311600000000000015204 0ustar00chrisusers[egg_info] tag_build = tag_date = 0 [aliases] release = build filltmpl egg_info -Db "" sdist --formats=zip,gztar bdist_wheel [filltmpl] templates = INSTALL.rst.in [build_sphinx] source-dir = docs/ build-dir = docs/build all_files = 1 [upload_sphinx] upload-dir = docs/build/html [flake8] ignore = E116, E265, E266, E731, W504 max-line-length = 100 exclude = examples/osc2midi/lru_cache.py [pydocstyle] match = (?!test_).*\.pyx? match_dir = (src|rtmidi) [metadata] name = python-rtmidi description = A Python binding for the RtMidi C++ library implemented using Cython. author = Christopher Arndt author_email = chris@chrisarndt.de license = MIT License long_description = file: README.rst url = https://github.com/SpotlightKid/python-rtmidi download_url = https://pypi.python.org/pypi/python-rtmidi repository = https://github.com/SpotlightKid/python-rtmidi.git keywords = midi music rtmidi classifiers = Development Status :: 5 - Production/Stable Environment :: MacOS X Environment :: Win32 (MS Windows) Environment :: Console Intended Audience :: Developers License :: OSI Approved :: MIT License Operating System :: Microsoft :: Windows Operating System :: POSIX Operating System :: MacOS :: MacOS X Programming Language :: Python Programming Language :: Python :: 3 Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 Topic :: Multimedia :: Sound/Audio :: MIDI Topic :: Software Development :: Libraries :: Python Modules [options] zip_safe = False include_package_data = True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611766025.0 python-rtmidi-1.4.7/setup.py0000644000175000001440000001441300000000000015077 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Setup file for the Cython rtmidi wrapper.""" from __future__ import print_function import subprocess import sys from ctypes.util import find_library from os.path import dirname, exists, join from setuptools import setup # needs to stay before the imports below! import distutils from distutils.dist import DistributionMetadata from distutils.extension import Extension from distutils.version import StrictVersion from fill_template import FillTemplate try: from Cython.Build import cythonize except ImportError: cythonize = None JACK1_MIN_VERSION = StrictVersion('0.125.0') JACK2_MIN_VERSION = StrictVersion('1.9.11') def read(*args): return open(join(dirname(__file__), *args)).read() def check_for_jack(define_macros, libraries): """Check for presence of jack library and set defines and libraries accordingly.""" if find_library('jack'): define_macros.append(('__UNIX_JACK__', None)) # Check version of jack whether it is "new" enough to have the # 'jack_port_rename' function: try: res = subprocess.check_output(['pkg-config', '--modversion', 'jack']) jv = StrictVersion(res.decode()) except (subprocess.CalledProcessError, UnicodeError, ValueError): pass else: print("Detected JACK version %s." % jv, file=sys.stderr) if ((jv.version[0] == 0 and jv >= JACK1_MIN_VERSION) or (jv.version[0] == 1 and jv >= JACK2_MIN_VERSION)): print("JACK version is recent enough to have 'jack_port_rename' function.", file=sys.stderr) define_macros.append(('JACK_HAS_PORT_RENAME', None)) libraries.append('jack') class ToxTestCommand(distutils.cmd.Command): """Distutils command to run tests via tox with 'python setup.py test'. Please note that in this configuration tox uses the dependencies in `requirements/dev.txt`, the list of dependencies in `tests_require` in `setup.py` is ignored! See https://docs.python.org/3/distutils/apiref.html#creating-a-new-distutils-command for more documentation on custom distutils commands. """ description = "Run tests via 'tox'." user_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): self.announce("Running tests with 'tox'...", level=distutils.log.INFO) return subprocess.call(['tox']) # source package structure SRC_DIR = "src" PKG_DIR = "rtmidi" # Add custom distribution meta-data, avoids warning when running setup DistributionMetadata.repository = None # Read version number from version.py (without importing the 'rtmidi' package, # since that would lead to hen-egg situation). setup_opts = {} exec(read(PKG_DIR, 'version.py'), {}, setup_opts) # Add our own custom distutils command to create *.rst files from templates # Template files are listed in setup.cfg setup_opts.setdefault('cmdclass', {}) setup_opts['cmdclass']['filltmpl'] = FillTemplate # Add custom test command setup_opts['cmdclass']['test'] = ToxTestCommand # Set up options for compiling the _rtmidi Extension if cythonize: sources = [join(SRC_DIR, "_rtmidi.pyx"), join(SRC_DIR, "rtmidi", "RtMidi.cpp")] elif exists(join(SRC_DIR, "_rtmidi.cpp")): cythonize = lambda x: x # noqa sources = [join(SRC_DIR, "_rtmidi.cpp"), join(SRC_DIR, "rtmidi", "RtMidi.cpp")] else: sys.exit("""\ Could not import Cython. Cython >= 0.28 is required to compile the Cython source into the C++ source. Install Cython from https://pypi.python.org/pypi/Cython or use the pre-generated '_rtmidi.cpp' file from the python-rtmidi source distribution. """) define_macros = [] include_dirs = [join(SRC_DIR, "rtmidi")] libraries = [] extra_link_args = [] extra_compile_args = [] alsa = coremidi = jack = winmm = True if '--no-alsa' in sys.argv: alsa = False sys.argv.remove('--no-alsa') if '--no-coremidi' in sys.argv: coremidi = False sys.argv.remove('--no-coremidi') if '--no-jack' in sys.argv: jack = False sys.argv.remove('--no-jack') if '--no-winmm' in sys.argv: winmm = False sys.argv.remove('--no-winmm') if '--no-suppress-warnings' not in sys.argv: define_macros.append(('__RTMIDI_SILENCE_WARNINGS__', None)) else: sys.argv.remove('--no-suppress-warnings') if sys.platform.startswith('linux'): if alsa and find_library('asound'): define_macros.append(("__LINUX_ALSA__", None)) libraries.append('asound') if jack: check_for_jack(define_macros, libraries) if not find_library('pthread'): sys.exit("The 'pthread' library is required to build python-rtmidi on" "Linux. Please install the libc6 development package.") libraries.append("pthread") elif sys.platform.startswith('darwin'): if jack: check_for_jack(define_macros, libraries) if coremidi: define_macros.append(('__MACOSX_CORE__', None)) extra_compile_args.append('-frtti') extra_link_args.extend([ '-framework', 'CoreAudio', '-framework', 'CoreMIDI', '-framework', 'CoreFoundation']) elif sys.platform.startswith('win'): extra_compile_args.append('/EHsc') if winmm: define_macros.append(('__WINDOWS_MM__', None)) libraries.append("winmm") else: print("WARNING: This operating system (%s) is not supported by RtMidi.\n" "Linux, macOS (OS X) (>= 10.5), Windows (XP, Vista, 7/8/10) are supported.\n" "Continuing and hoping for the best..." % sys.platform, file=sys.stderr) # define _rtmidi Extension extensions = [ Extension( PKG_DIR + "._rtmidi", sources=sources, language="c++", define_macros=define_macros, include_dirs=include_dirs, libraries=libraries, extra_compile_args=extra_compile_args, extra_link_args=extra_link_args ) ] # Finally, set up our distribution setup( packages=['rtmidi'], ext_modules=cythonize(extensions), tests_require=[], # Test dependencies are handled by tox # On systems without a RTC (e.g. Raspberry Pi), system time will be the # Unix epoch when booted without network connection, which makes zip fail, # because it does not support dates < 1980-01-01. **setup_opts ) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2524176 python-rtmidi-1.4.7/src/0000755000175000001440000000000000000000000014151 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611779473.0 python-rtmidi-1.4.7/src/_rtmidi.cpp0000644000175000001440000262314700000000000016323 0ustar00chrisusers/* Generated by Cython 0.29.21 */ /* BEGIN: Cython Metadata { "distutils": { "define_macros": [ [ "__RTMIDI_SILENCE_WARNINGS__", null ], [ "__LINUX_ALSA__", null ], [ "__UNIX_JACK__", null ], [ "JACK_HAS_PORT_RENAME", null ] ], "depends": [ "src/pyinit.h", "src/rtmidi/RtMidi.h" ], "include_dirs": [ "src", "src/rtmidi" ], "language": "c++", "libraries": [ "asound", "jack", "pthread" ], "name": "rtmidi._rtmidi", "sources": [ "src/_rtmidi.pyx", "src/rtmidi/RtMidi.cpp" ] }, "module_name": "rtmidi._rtmidi" } END: Cython Metadata */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_21" #define CYTHON_HEX_VERSION 0x001D15F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef __cplusplus #error "Cython files generated with the C++ option must be compiled with a C++ compiler." #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #else #define CYTHON_INLINE inline #endif #endif template void __Pyx_call_destructor(T& x) { x.~T(); } template class __Pyx_FakeReference { public: __Pyx_FakeReference() : ptr(NULL) { } __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } T *operator->() { return ptr; } T *operator&() { return ptr; } operator T&() { return *ptr; } template bool operator ==(U other) { return *ptr == other; } template bool operator !=(U other) { return *ptr != other; } private: T *ptr; }; #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__rtmidi___rtmidi #define __PYX_HAVE_API__rtmidi___rtmidi /* Early includes */ #include #include "ios" #include "new" #include "stdexcept" #include "typeinfo" #include #include #include "pyinit.h" #include "RtMidi.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "src/_rtmidi.pyx", "stringsource", }; /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release #define __Pyx_FastGIL_Remember() #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() /*--- Type declarations ---*/ struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase; struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn; struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut; /* "src/_rtmidi.pyx":431 * * * cdef class MidiBase: # <<<<<<<<<<<<<< * cdef object _port * cdef object _error_callback */ struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase { PyObject_HEAD struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *__pyx_vtab; PyObject *_port; PyObject *_error_callback; PyObject *_deleted; }; /* "src/_rtmidi.pyx":757 * * * cdef class MidiIn(MidiBase): # <<<<<<<<<<<<<< * """Midi input client interface. * */ struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn { struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase __pyx_base; RtMidiIn *thisptr; PyObject *_callback; }; /* "src/_rtmidi.pyx":969 * * * cdef class MidiOut(MidiBase): # <<<<<<<<<<<<<< * """Midi output client interface. * */ struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut { struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase __pyx_base; RtMidiOut *thisptr; }; /* "src/_rtmidi.pyx":431 * * * cdef class MidiBase: # <<<<<<<<<<<<<< * cdef object _port * cdef object _error_callback */ struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase { RtMidi *(*baseptr)(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *); }; static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *__pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase; /* "src/_rtmidi.pyx":757 * * * cdef class MidiIn(MidiBase): # <<<<<<<<<<<<<< * """Midi input client interface. * */ struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiIn { struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase __pyx_base; }; static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiIn *__pyx_vtabptr_6rtmidi_7_rtmidi_MidiIn; /* "src/_rtmidi.pyx":969 * * * cdef class MidiOut(MidiBase): # <<<<<<<<<<<<<< * """Midi output client interface. * */ struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiOut { struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase __pyx_base; }; static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiOut *__pyx_vtabptr_6rtmidi_7_rtmidi_MidiOut; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* IncludeCppStringH.proto */ #include /* decode_c_string_utf16.proto */ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 0; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = -1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } /* decode_c_bytes.proto */ static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); /* decode_cpp_string.proto */ static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( std::string cppstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { return __Pyx_decode_c_bytes( cppstring.data(), cppstring.size(), start, stop, encoding, errors, decode_func); } /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyIntCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* PyObjectFormatAndDecref.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); /* PyUnicode_Unicode.proto */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj); /* IncludeStringH.proto */ #include /* JoinPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* PyIntCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* CalculateMetaclass.proto */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) #elif CYTHON_COMPILING_IN_CPYTHON #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) #else #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED 1 #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { PyCFunctionObject func; #if PY_VERSION_HEX < 0x030500A0 PyObject *func_weakreflist; #endif PyObject *func_dict; PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; PyObject *func_classobj; void *defaults; int defaults_pyobjects; size_t defaults_size; // used by FusedFunction for copying defaults int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, size_t size, int pyobjects); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(void); /* CythonFunction.proto */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); /* Py3ClassCreate.proto */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc); static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); /* CyFunctionClassCell.proto */ static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj); /* GetNameInClass.proto */ #define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(enum RtMidi::Api value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(enum RtMidiError::Type value); /* CppExceptionConversion.proto */ #ifndef __Pyx_CppExn2PyErr #include #include #include #include static void __Pyx_CppExn2PyErr() { try { if (PyErr_Occurred()) ; // let the latest Python exn pass through and ignore the current one else throw; } catch (const std::bad_alloc& exn) { PyErr_SetString(PyExc_MemoryError, exn.what()); } catch (const std::bad_cast& exn) { PyErr_SetString(PyExc_TypeError, exn.what()); } catch (const std::bad_typeid& exn) { PyErr_SetString(PyExc_TypeError, exn.what()); } catch (const std::domain_error& exn) { PyErr_SetString(PyExc_ValueError, exn.what()); } catch (const std::invalid_argument& exn) { PyErr_SetString(PyExc_ValueError, exn.what()); } catch (const std::ios_base::failure& exn) { PyErr_SetString(PyExc_IOError, exn.what()); } catch (const std::out_of_range& exn) { PyErr_SetString(PyExc_IndexError, exn.what()); } catch (const std::overflow_error& exn) { PyErr_SetString(PyExc_OverflowError, exn.what()); } catch (const std::range_error& exn) { PyErr_SetString(PyExc_ArithmeticError, exn.what()); } catch (const std::underflow_error& exn) { PyErr_SetString(PyExc_ArithmeticError, exn.what()); } catch (const std::exception& exn) { PyErr_SetString(PyExc_RuntimeError, exn.what()); } catch (...) { PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); } } #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE enum RtMidi::Api __Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static RtMidi *__pyx_f_6rtmidi_7_rtmidi_8MidiBase_baseptr(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto*/ static RtMidi *__pyx_f_6rtmidi_7_rtmidi_6MidiIn_baseptr(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto*/ static RtMidi *__pyx_f_6rtmidi_7_rtmidi_7MidiOut_baseptr(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto*/ /* Module declarations from 'libcpp' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libcpp.string' */ /* Module declarations from 'libcpp.vector' */ /* Module declarations from 'rtmidi._rtmidi' */ static PyTypeObject *__pyx_ptype_6rtmidi_7_rtmidi_MidiBase = 0; static PyTypeObject *__pyx_ptype_6rtmidi_7_rtmidi_MidiIn = 0; static PyTypeObject *__pyx_ptype_6rtmidi_7_rtmidi_MidiOut = 0; static void __pyx_f_6rtmidi_7_rtmidi__cb_func(double, std::vector *, void *); /*proto*/ static void __pyx_f_6rtmidi_7_rtmidi__cb_error_func(enum RtMidiError::Type, std::string const &, void *); /*proto*/ static PyObject *__pyx_f_6rtmidi_7_rtmidi___pyx_unpickle_MidiBase__set_state(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *, PyObject *); /*proto*/ static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &); /*proto*/ static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &); /*proto*/ static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &); /*proto*/ static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &); /*proto*/ static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &); /*proto*/ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "rtmidi._rtmidi" extern int __pyx_module_is_main_rtmidi___rtmidi; int __pyx_module_is_main_rtmidi___rtmidi = 0; /* Implementation of 'rtmidi._rtmidi' */ static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_OSError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_super; static PyObject *__pyx_builtin_NotImplementedError; static const char __pyx_k_i[] = "i"; static const char __pyx_k_s[] = "s"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_api[] = "api"; static const char __pyx_k_doc[] = "__doc__"; static const char __pyx_k_msg[] = "msg"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_win[] = "win"; static const char __pyx_k_None[] = "None"; static const char __pyx_k_auto[] = "auto"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_func[] = "func"; static const char __pyx_k_init[] = "__init__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_port[] = " port."; static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_type[] = "type"; static const char __pyx_k_warn[] = "warn"; static const char __pyx_k_api_v[] = "api_v"; static const char __pyx_k_etype[] = "etype"; static const char __pyx_k_input[] = "input"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_rtapi[] = "rtapi"; static const char __pyx_k_super[] = "super"; static const char __pyx_k_sysex[] = "sysex"; static const char __pyx_k_utf_8[] = "utf-8"; static const char __pyx_k_MidiIn[] = "MidiIn"; static const char __pyx_k_darwin[] = "darwin"; static const char __pyx_k_decode[] = "decode"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_ignore[] = "ignore"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_latin1[] = "latin1"; static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_output[] = "output"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_port_2[] = "port"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_timing[] = "timing"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_MidiOut[] = "MidiOut"; static const char __pyx_k_OSError[] = "OSError"; static const char __pyx_k_prepare[] = "__prepare__"; static const char __pyx_k_thisptr[] = "thisptr"; static const char __pyx_k_MidiBase[] = "MidiBase"; static const char __pyx_k_RtMidi_s[] = "RtMidi %s"; static const char __pyx_k_encoding[] = "encoding"; static const char __pyx_k_endswith[] = "endswith"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_macroman[] = "macroman"; static const char __pyx_k_platform[] = "platform"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_qualname[] = "__qualname__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_to_bytes[] = "_to_bytes"; static const char __pyx_k_warnings[] = "warnings"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_check_port[] = "_check_port"; static const char __pyx_k_close_port[] = "close_port"; static const char __pyx_k_is_invalid[] = "is invalid."; static const char __pyx_k_portNumber[] = "portNumber"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_startswith[] = "startswith"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_RtMidiError[] = "RtMidiError"; static const char __pyx_k_SystemError[] = "SystemError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_active_sense[] = "active_sense"; static const char __pyx_k_get_api_name[] = "get_api_name"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_string_types[] = "string_types"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_API_UNIX_JACK[] = "API_UNIX_JACK"; static const char __pyx_k_decode_string[] = "_decode_string"; static const char __pyx_k_get_port_name[] = "get_port_name"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_API_LINUX_ALSA[] = "API_LINUX_ALSA"; static const char __pyx_k_API_WINDOWS_MM[] = "API_WINDOWS_MM"; static const char __pyx_k_NoDevicesError[] = "NoDevicesError"; static const char __pyx_k_get_port_count[] = "get_port_count"; static const char __pyx_k_rtmidi__rtmidi[] = "rtmidi._rtmidi"; static const char __pyx_k_API_MACOSX_CORE[] = "API_MACOSX_CORE"; static const char __pyx_k_API_UNSPECIFIED[] = "API_UNSPECIFIED"; static const char __pyx_k_InvalidUseError[] = "InvalidUseError"; static const char __pyx_k_RtMidiIn_Client[] = "RtMidiIn Client"; static const char __pyx_k_cancel_callback[] = "cancel_callback"; static const char __pyx_k_get_current_api[] = "get_current_api"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_src__rtmidi_pyx[] = "src/_rtmidi.pyx"; static const char __pyx_k_API_RTMIDI_DUMMY[] = "API_RTMIDI_DUMMY"; static const char __pyx_k_InvalidPortError[] = "InvalidPortError"; static const char __pyx_k_RtMidiOut_Client[] = "RtMidiOut Client"; static const char __pyx_k_RtMidi_virtual_s[] = "RtMidi virtual %s"; static const char __pyx_k_get_compiled_api[] = "get_compiled_api"; static const char __pyx_k_queue_size_limit[] = "queue_size_limit"; static const char __pyx_k_ERRORTYPE_WARNING[] = "ERRORTYPE_WARNING"; static const char __pyx_k_RtMidiError___init[] = "RtMidiError.__init__"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_get_rtmidi_version[] = "get_rtmidi_version"; static const char __pyx_k_no_ports_available[] = "no ports available!"; static const char __pyx_k_set_error_callback[] = "set_error_callback"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_event_parsing_error[] = "event parsing error!"; static const char __pyx_k_get_api_display_name[] = "get_api_display_name"; static const char __pyx_k_ERRORTYPE_INVALID_USE[] = "ERRORTYPE_INVALID_USE"; static const char __pyx_k_ERRORTYPE_UNSPECIFIED[] = "ERRORTYPE_UNSPECIFIED"; static const char __pyx_k_MemoryAllocationError[] = "MemoryAllocationError"; static const char __pyx_k_default_error_handler[] = "_default_error_handler"; static const char __pyx_k_pyx_unpickle_MidiBase[] = "__pyx_unpickle_MidiBase"; static const char __pyx_k_ERRORTYPE_DRIVER_ERROR[] = "ERRORTYPE_DRIVER_ERROR"; static const char __pyx_k_ERRORTYPE_MEMORY_ERROR[] = "ERRORTYPE_MEMORY_ERROR"; static const char __pyx_k_ERRORTYPE_SYSTEM_ERROR[] = "ERRORTYPE_SYSTEM_ERROR"; static const char __pyx_k_ERRORTYPE_THREAD_ERROR[] = "ERRORTYPE_THREAD_ERROR"; static const char __pyx_k_already_opened_virtual[] = " already opened virtual "; static const char __pyx_k_ERRORTYPE_DEBUG_WARNING[] = "ERRORTYPE_DEBUG_WARNING"; static const char __pyx_k_JACK_server_not_running[] = "JACK server not running?"; static const char __pyx_k_ERRORTYPE_INVALID_DEVICE[] = "ERRORTYPE_INVALID_DEVICE"; static const char __pyx_k_No_port_currently_opened[] = "No port currently opened."; static const char __pyx_k_get_compiled_api_by_name[] = "get_compiled_api_by_name"; static const char __pyx_k_UnsupportedOperationError[] = "UnsupportedOperationError"; static const char __pyx_k_message_must_not_be_empty[] = "'message' must not be empty."; static const char __pyx_k_r_already_opened_s_port_i[] = "%r already opened %s port %i."; static const char __pyx_k_ERRORTYPE_NO_DEVICES_FOUND[] = "ERRORTYPE_NO_DEVICES_FOUND"; static const char __pyx_k_ERRORTYPE_INVALID_PARAMETER[] = "ERRORTYPE_INVALID_PARAMETER"; static const char __pyx_k_error_looking_for_port_name[] = "error looking for port name!"; static const char __pyx_k_A_Python_binding_for_the_RtMidi[] = "A Python binding for the RtMidi C++ library implemented using Cython.\n\nOverview\n========\n\n**RtMidi** is a set of C++ classes which provides a concise and simple,\ncross-platform API (Application Programming Interface) for realtime MIDI\ninput / output across Linux (ALSA & JACK), macOS / OS X (CoreMIDI & JACK),\nand Windows (MultiMedia System) operating systems.\n\n**python-rtmidi** is a Python binding for RtMidi implemented using Cython_ and\nprovides a thin wrapper around the RtMidi C++ interface. The API is basically\nthe same as the C++ one but with the naming scheme of classes, methods and\nparameters adapted to the Python PEP-8 conventions and requirements of the\nPython package naming structure. **python-rtmidi** supports Python 3 (3.6, 3.7,\n3.8, and 3.9).\n\n\nUsage example\n=============\n\nHere's a short example of how to use **python-rtmidi** to open the first\navailable MIDI output port and send a middle C note on MIDI channel 1::\n\n import time\n import rtmidi\n\n midiout = rtmidi.MidiOut()\n available_ports = midiout.get_ports()\n\n if available_ports:\n midiout.open_port(0)\n else:\n midiout.open_virtual_port(\"My virtual output\")\n\n with midiout:\n note_on = [0x90, 60, 112] # channel 1, middle C, velocity 112\n note_off = [0x80, 60, 0]\n midiout.send_message(note_on)\n time.sleep(0.5)\n midiout.send_message(note_off)\n time.sleep(0.1)\n\n del midiout\n\n\nConstants\n=========\n\n\nLow-level APIs\n--------------\n\nThese constants are returned by the ``get_compiled_api`` function and the\n``MidiIn.get_current_api`` resp. ``MidiOut.get_current_api`` methods and are\nused to specify the low-level MIDI backend API to use when creating a\n``MidiIn`` or ``MidiOut`` instance.\n\n``API_UNSPECIFIED``\n Use first compiled-in API, which has any input resp. output ports\n``API_MACOSX_CORE``\n macOS (OS X) CoreMIDI\n``API_LINUX_ALSA``\n Linux ALSA\n``API_UNIX_JACK``""\n Jack Client\n``API_WINDOWS_MM``\n Windows MultiMedia\n``API_RTMIDI_DUMMY``\n RtMidi Dummy API (used when no suitable API was found)\n\n\nError types\n-----------\n\nThese constants are passed as the first argument to an error handler\nfunction registered with ``set_error_callback`` method of a ``MidiIn``\nor ``MidiOut`` instance. For the meaning of each value, please see\nthe `RtMidi API reference`_.\n\n* ``ERRORTYPE_DEBUG_WARNING``\n* ``ERRORTYPE_DRIVER_ERROR``\n* ``ERRORTYPE_INVALID_DEVICE``\n* ``ERRORTYPE_INVALID_PARAMETER``\n* ``ERRORTYPE_INVALID_USE``\n* ``ERRORTYPE_MEMORY_ERROR``\n* ``ERRORTYPE_NO_DEVICES_FOUND``\n* ``ERRORTYPE_SYSTEM_ERROR``\n* ``ERRORTYPE_THREAD_ERROR``\n* ``ERRORTYPE_UNSPECIFIED``\n* ``ERRORTYPE_WARNING``\n\n\n.. _cython: http://cython.org/\n.. _rtmidi api reference:\n http://www.music.mcgill.ca/~gary/rtmidi/classRtMidiError.html\n\n"; static const char __pyx_k_Virtual_ports_are_not_supported[] = "Virtual ports are not supported by the Windows MultiMedia API."; static const char __pyx_k_message_longer_than_3_bytes_but[] = "'message' longer than 3 bytes but does not start with 0xF0."; static const char __pyx_k_API_backend_does_not_support_cha[] = "API backend does not support changing the client name."; static const char __pyx_k_Base_general_RtMidi_exception_Al[] = "Base general RtMidi exception.\n\n All other exceptions in this module derive form this exception.\n\n Instances have a ``type`` attribute that maps to one of the\n ``ERRORTYPE_*`` constants.\n\n "; static const char __pyx_k_Incompatible_checksums_s_vs_0x91[] = "Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))"; static const char __pyx_k_Raised_if_a_memory_allocation_fa[] = "Raised if a memory allocation failed on the C++ level.\n\n Also derives from ``MemoryError``.\n\n "; static const char __pyx_k_Raised_if_a_method_is_not_suppor[] = "Raised if a method is not supported by the low-level API.\n\n Also derives from ``RuntimeError``.\n\n "; static const char __pyx_k_Raised_if_an_error_happened_at_t[] = "Raised if an error happened at the MIDI driver or OS level.\n\n Also derives from ``OSError``.\n\n "; static const char __pyx_k_Raised_if_no_MIDI_devices_are_fo[] = "Raised if no MIDI devices are found.\n\n Derives from ``rtmidi.SystemError``.\n\n "; static const char __pyx_k_Raised_when_an_invalid_port_numb[] = "Raised when an invalid port number is used.\n\n Also derives from ``ValueError``.\n\n "; static const char __pyx_k_Raised_when_an_method_call_is_no[] = "Raised when an method call is not allowed in the current state.\n\n Also derives from ``RuntimeError``.\n\n "; static const char __pyx_k_error_sending_MIDI_message_to_po[] = "error sending MIDI message to port."; static const char __pyx_k_error_sending_MIDI_to_virtual_de[] = "error sending MIDI to virtual destinations."; static const char __pyx_k_name_must_be_bytes_or_unicode_st[] = "name must be bytes or (unicode) string."; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_API_backend_does_not_support_cha_2[] = "API backend does not support changing the port name."; static PyObject *__pyx_n_s_API_LINUX_ALSA; static PyObject *__pyx_n_u_API_LINUX_ALSA; static PyObject *__pyx_n_s_API_MACOSX_CORE; static PyObject *__pyx_n_u_API_MACOSX_CORE; static PyObject *__pyx_n_s_API_RTMIDI_DUMMY; static PyObject *__pyx_n_u_API_RTMIDI_DUMMY; static PyObject *__pyx_n_s_API_UNIX_JACK; static PyObject *__pyx_n_u_API_UNIX_JACK; static PyObject *__pyx_n_s_API_UNSPECIFIED; static PyObject *__pyx_n_u_API_UNSPECIFIED; static PyObject *__pyx_n_s_API_WINDOWS_MM; static PyObject *__pyx_n_u_API_WINDOWS_MM; static PyObject *__pyx_kp_u_API_backend_does_not_support_cha; static PyObject *__pyx_kp_u_API_backend_does_not_support_cha_2; static PyObject *__pyx_kp_s_Base_general_RtMidi_exception_Al; static PyObject *__pyx_n_s_ERRORTYPE_DEBUG_WARNING; static PyObject *__pyx_n_u_ERRORTYPE_DEBUG_WARNING; static PyObject *__pyx_n_s_ERRORTYPE_DRIVER_ERROR; static PyObject *__pyx_n_u_ERRORTYPE_DRIVER_ERROR; static PyObject *__pyx_n_s_ERRORTYPE_INVALID_DEVICE; static PyObject *__pyx_n_u_ERRORTYPE_INVALID_DEVICE; static PyObject *__pyx_n_s_ERRORTYPE_INVALID_PARAMETER; static PyObject *__pyx_n_u_ERRORTYPE_INVALID_PARAMETER; static PyObject *__pyx_n_s_ERRORTYPE_INVALID_USE; static PyObject *__pyx_n_u_ERRORTYPE_INVALID_USE; static PyObject *__pyx_n_s_ERRORTYPE_MEMORY_ERROR; static PyObject *__pyx_n_u_ERRORTYPE_MEMORY_ERROR; static PyObject *__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND; static PyObject *__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND; static PyObject *__pyx_n_s_ERRORTYPE_SYSTEM_ERROR; static PyObject *__pyx_n_u_ERRORTYPE_SYSTEM_ERROR; static PyObject *__pyx_n_s_ERRORTYPE_THREAD_ERROR; static PyObject *__pyx_n_u_ERRORTYPE_THREAD_ERROR; static PyObject *__pyx_n_s_ERRORTYPE_UNSPECIFIED; static PyObject *__pyx_n_u_ERRORTYPE_UNSPECIFIED; static PyObject *__pyx_n_s_ERRORTYPE_WARNING; static PyObject *__pyx_n_u_ERRORTYPE_WARNING; static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x91; static PyObject *__pyx_n_s_InvalidPortError; static PyObject *__pyx_n_u_InvalidPortError; static PyObject *__pyx_n_s_InvalidUseError; static PyObject *__pyx_n_u_InvalidUseError; static PyObject *__pyx_kp_u_JACK_server_not_running; static PyObject *__pyx_n_s_MemoryAllocationError; static PyObject *__pyx_n_u_MemoryAllocationError; static PyObject *__pyx_n_s_MemoryError; static PyObject *__pyx_n_s_MidiBase; static PyObject *__pyx_n_s_MidiIn; static PyObject *__pyx_n_u_MidiIn; static PyObject *__pyx_n_s_MidiOut; static PyObject *__pyx_n_u_MidiOut; static PyObject *__pyx_n_s_NoDevicesError; static PyObject *__pyx_n_u_NoDevicesError; static PyObject *__pyx_kp_u_No_port_currently_opened; static PyObject *__pyx_kp_u_None; static PyObject *__pyx_n_s_NotImplementedError; static PyObject *__pyx_n_s_OSError; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_kp_s_Raised_if_a_memory_allocation_fa; static PyObject *__pyx_kp_s_Raised_if_a_method_is_not_suppor; static PyObject *__pyx_kp_s_Raised_if_an_error_happened_at_t; static PyObject *__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo; static PyObject *__pyx_kp_s_Raised_when_an_invalid_port_numb; static PyObject *__pyx_kp_s_Raised_when_an_method_call_is_no; static PyObject *__pyx_n_s_RtMidiError; static PyObject *__pyx_n_u_RtMidiError; static PyObject *__pyx_n_s_RtMidiError___init; static PyObject *__pyx_kp_u_RtMidiIn_Client; static PyObject *__pyx_kp_u_RtMidiOut_Client; static PyObject *__pyx_kp_u_RtMidi_s; static PyObject *__pyx_kp_u_RtMidi_virtual_s; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_SystemError; static PyObject *__pyx_n_u_SystemError; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_UnsupportedOperationError; static PyObject *__pyx_n_u_UnsupportedOperationError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_u_Virtual_ports_are_not_supported; static PyObject *__pyx_n_s_active_sense; static PyObject *__pyx_n_s_all; static PyObject *__pyx_kp_u_already_opened_virtual; static PyObject *__pyx_n_s_api; static PyObject *__pyx_n_s_api_v; static PyObject *__pyx_n_u_auto; static PyObject *__pyx_n_s_cancel_callback; static PyObject *__pyx_n_s_check_port; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_close_port; static PyObject *__pyx_n_u_darwin; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_n_s_decode_string; static PyObject *__pyx_n_s_default_error_handler; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_doc; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_encoding; static PyObject *__pyx_n_s_endswith; static PyObject *__pyx_kp_u_error_looking_for_port_name; static PyObject *__pyx_kp_u_error_sending_MIDI_message_to_po; static PyObject *__pyx_kp_u_error_sending_MIDI_to_virtual_de; static PyObject *__pyx_n_s_etype; static PyObject *__pyx_kp_u_event_parsing_error; static PyObject *__pyx_n_s_func; static PyObject *__pyx_n_s_get_api_display_name; static PyObject *__pyx_n_u_get_api_display_name; static PyObject *__pyx_n_s_get_api_name; static PyObject *__pyx_n_u_get_api_name; static PyObject *__pyx_n_s_get_compiled_api; static PyObject *__pyx_n_u_get_compiled_api; static PyObject *__pyx_n_s_get_compiled_api_by_name; static PyObject *__pyx_n_u_get_compiled_api_by_name; static PyObject *__pyx_n_s_get_current_api; static PyObject *__pyx_n_s_get_port_count; static PyObject *__pyx_n_s_get_port_name; static PyObject *__pyx_n_s_get_rtmidi_version; static PyObject *__pyx_n_u_get_rtmidi_version; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_u_ignore; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_u_input; static PyObject *__pyx_kp_u_is_invalid; static PyObject *__pyx_n_u_latin1; static PyObject *__pyx_n_u_macroman; static PyObject *__pyx_n_s_main; static PyObject *__pyx_kp_u_message_longer_than_3_bytes_but; static PyObject *__pyx_kp_u_message_must_not_be_empty; static PyObject *__pyx_n_s_metaclass; static PyObject *__pyx_n_s_module; static PyObject *__pyx_n_s_msg; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_kp_u_name_must_be_bytes_or_unicode_st; static PyObject *__pyx_n_s_new; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_kp_u_no_ports_available; static PyObject *__pyx_n_u_output; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_platform; static PyObject *__pyx_kp_u_port; static PyObject *__pyx_n_u_portNumber; static PyObject *__pyx_n_s_port_2; static PyObject *__pyx_n_s_prepare; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_MidiBase; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_qualname; static PyObject *__pyx_n_s_queue_size_limit; static PyObject *__pyx_kp_u_r_already_opened_s_port_i; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_rtapi; static PyObject *__pyx_n_s_rtmidi__rtmidi; static PyObject *__pyx_n_s_s; static PyObject *__pyx_n_s_self; static PyObject *__pyx_n_s_set_error_callback; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_kp_s_src__rtmidi_pyx; static PyObject *__pyx_n_s_startswith; static PyObject *__pyx_n_s_string_types; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_super; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_s_sysex; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_u_thisptr; static PyObject *__pyx_n_s_timing; static PyObject *__pyx_n_s_to_bytes; static PyObject *__pyx_n_s_type; static PyObject *__pyx_n_s_update; static PyObject *__pyx_kp_u_utf_8; static PyObject *__pyx_n_s_warn; static PyObject *__pyx_n_s_warnings; static PyObject *__pyx_n_u_win; static PyObject *__pyx_pf_6rtmidi_7_rtmidi__to_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_11RtMidiError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_type); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_2get_api_display_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_4get_api_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6get_compiled_api(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8get_compiled_api_by_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_10get_rtmidi_version(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_12_default_error_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_etype, PyObject *__pyx_v_msg, CYTHON_UNUSED PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase___enter__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_2__exit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_info); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_4_check_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_6_decode_string(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_8get_port_count(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_10get_port_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_12get_ports(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_14is_port_open(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_16open_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_18open_virtual_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_20close_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_22set_client_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_24set_port_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_26set_error_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_28cancel_error_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_30__reduce_cython__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_32__setstate_cython__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6rtmidi_7_rtmidi_6MidiIn___cinit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, enum RtMidi::Api __pyx_v_rtapi, PyObject *__pyx_v_name, unsigned int __pyx_v_queue_size_limit); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_2get_current_api(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static void __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_4__dealloc__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_6delete(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10is_deleted___get__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_8cancel_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10close_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_12get_message(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_14ignore_types(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_sysex, PyObject *__pyx_v_timing, PyObject *__pyx_v_active_sense); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_16set_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_6rtmidi_7_rtmidi_7MidiOut___cinit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, enum RtMidi::Api __pyx_v_rtapi, PyObject *__pyx_v_name); /* proto */ static void __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_2__dealloc__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_4delete(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10is_deleted___get__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_6get_current_api(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_8send_message(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, PyObject *__pyx_v_message); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_6rtmidi_7_rtmidi_14__pyx_unpickle_MidiBase(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiBase(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiIn(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiOut(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_240; static PyObject *__pyx_int_152509455; static PyObject *__pyx_int_neg_1; static enum RtMidi::Api __pyx_k__4; static enum RtMidi::Api __pyx_k__7; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__29; static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__16; static PyObject *__pyx_codeobj__19; static PyObject *__pyx_codeobj__21; static PyObject *__pyx_codeobj__23; static PyObject *__pyx_codeobj__25; static PyObject *__pyx_codeobj__26; static PyObject *__pyx_codeobj__28; static PyObject *__pyx_codeobj__30; /* Late includes */ /* "src/_rtmidi.pyx":208 * # internal functions * * cdef void _cb_func(double delta_time, vector[unsigned char] *msg_v, # <<<<<<<<<<<<<< * void *cb_info) with gil: * """Wrapper for a Python callback function for MIDI input.""" */ static void __pyx_f_6rtmidi_7_rtmidi__cb_func(double __pyx_v_delta_time, std::vector *__pyx_v_msg_v, void *__pyx_v_cb_info) { PyObject *__pyx_v_func = NULL; PyObject *__pyx_v_data = NULL; PyObject *__pyx_v_message = NULL; std::vector ::size_type __pyx_7genexpr__pyx_v_i; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *(*__pyx_t_5)(PyObject *); std::vector ::size_type __pyx_t_6; std::vector ::size_type __pyx_t_7; std::vector ::size_type __pyx_t_8; __Pyx_FakeReference __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_cb_func", 0); /* "src/_rtmidi.pyx":211 * void *cb_info) with gil: * """Wrapper for a Python callback function for MIDI input.""" * func, data = ( cb_info) # <<<<<<<<<<<<<< * message = [msg_v.at(i) for i in range(msg_v.size())] * func((message, delta_time), data) */ __pyx_t_1 = ((PyObject *)__pyx_v_cb_info); __Pyx_INCREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 211, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_2 = PyList_GET_ITEM(sequence, 0); __pyx_t_3 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); #else __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 211, __pyx_L1_error) __pyx_t_5 = NULL; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_unpacking_done; __pyx_L3_unpacking_failed:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 211, __pyx_L1_error) __pyx_L4_unpacking_done:; } __pyx_v_func = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_data = __pyx_t_3; __pyx_t_3 = 0; /* "src/_rtmidi.pyx":212 * """Wrapper for a Python callback function for MIDI input.""" * func, data = ( cb_info) * message = [msg_v.at(i) for i in range(msg_v.size())] # <<<<<<<<<<<<<< * func((message, delta_time), data) * */ { /* enter inner scope */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __pyx_v_msg_v->size(); __pyx_t_7 = __pyx_t_6; for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_7genexpr__pyx_v_i = __pyx_t_8; try { __pyx_t_9 = __pyx_v_msg_v->at(__pyx_7genexpr__pyx_v_i); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 212, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyInt_From_unsigned_char(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } } /* exit inner scope */ __pyx_v_message = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":213 * func, data = ( cb_info) * message = [msg_v.at(i) for i in range(msg_v.size())] * func((message, delta_time), data) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_message); __Pyx_GIVEREF(__pyx_v_message); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_message); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); __pyx_t_3 = 0; __Pyx_INCREF(__pyx_v_func); __pyx_t_3 = __pyx_v_func; __pyx_t_4 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_2, __pyx_v_data}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_2, __pyx_v_data}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif { __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_data); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":208 * # internal functions * * cdef void _cb_func(double delta_time, vector[unsigned char] *msg_v, # <<<<<<<<<<<<<< * void *cb_info) with gil: * """Wrapper for a Python callback function for MIDI input.""" */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("rtmidi._rtmidi._cb_func", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_func); __Pyx_XDECREF(__pyx_v_data); __Pyx_XDECREF(__pyx_v_message); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/_rtmidi.pyx":216 * * * cdef void _cb_error_func(ErrorType errorType, const string &errorText, # <<<<<<<<<<<<<< * void *cb_info) except * with gil: * """Wrapper for a Python callback function for errors.""" */ static void __pyx_f_6rtmidi_7_rtmidi__cb_error_func(enum RtMidiError::Type __pyx_v_errorType, std::string const &__pyx_v_errorText, void *__pyx_v_cb_info) { PyObject *__pyx_v_func = NULL; PyObject *__pyx_v_data = NULL; PyObject *__pyx_v_decoder = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_cb_error_func", 0); /* "src/_rtmidi.pyx":219 * void *cb_info) except * with gil: * """Wrapper for a Python callback function for errors.""" * func, data, decoder = ( cb_info) # <<<<<<<<<<<<<< * func(errorType, decoder(errorText), data) * */ __pyx_t_1 = ((PyObject *)__pyx_v_cb_info); __Pyx_INCREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 219, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_2 = PyList_GET_ITEM(sequence, 0); __pyx_t_3 = PyList_GET_ITEM(sequence, 1); __pyx_t_4 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 219, __pyx_L1_error) __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_unpacking_done; __pyx_L3_unpacking_failed:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 219, __pyx_L1_error) __pyx_L4_unpacking_done:; } __pyx_v_func = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_data = __pyx_t_3; __pyx_t_3 = 0; __pyx_v_decoder = __pyx_t_4; __pyx_t_4 = 0; /* "src/_rtmidi.pyx":220 * """Wrapper for a Python callback function for errors.""" * func, data, decoder = ( cb_info) * func(errorType, decoder(errorText), data) # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(__pyx_v_errorType); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_errorText); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_decoder); __pyx_t_5 = __pyx_v_decoder; __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_v_func); __pyx_t_5 = __pyx_v_func; __pyx_t_2 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_4, __pyx_t_3, __pyx_v_data}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_4, __pyx_t_3, __pyx_v_data}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_t_3); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_v_data); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":216 * * * cdef void _cb_error_func(ErrorType errorType, const string &errorText, # <<<<<<<<<<<<<< * void *cb_info) except * with gil: * """Wrapper for a Python callback function for errors.""" */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("rtmidi._rtmidi._cb_error_func", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_v_func); __Pyx_XDECREF(__pyx_v_data); __Pyx_XDECREF(__pyx_v_decoder); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/_rtmidi.pyx":223 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_1_to_bytes(PyObject *__pyx_self, PyObject *__pyx_v_name); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi__to_bytes[] = "_to_bytes(name)\nConvert a unicode (Python 2) or str (Python 3) object into bytes."; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_1_to_bytes = {"_to_bytes", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_1_to_bytes, METH_O, __pyx_doc_6rtmidi_7_rtmidi__to_bytes}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_1_to_bytes(PyObject *__pyx_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_to_bytes (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi__to_bytes(__pyx_self, ((PyObject *)__pyx_v_name)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi__to_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_to_bytes", 0); __Pyx_INCREF(__pyx_v_name); /* "src/_rtmidi.pyx":226 * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 * if isinstance(name, string_types): # <<<<<<<<<<<<<< * try: * name = bytes(name, 'utf-8') # Python 3 */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_string_types); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/_rtmidi.pyx":227 * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 * if isinstance(name, string_types): * try: # <<<<<<<<<<<<<< * name = bytes(name, 'utf-8') # Python 3 * except TypeError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); /*try:*/ { /* "src/_rtmidi.pyx":228 * if isinstance(name, string_types): * try: * name = bytes(name, 'utf-8') # Python 3 # <<<<<<<<<<<<<< * except TypeError: * name = name.encode('utf-8') # Python 2 */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_name); __Pyx_INCREF(__pyx_kp_u_utf_8); __Pyx_GIVEREF(__pyx_kp_u_utf_8); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_kp_u_utf_8); __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":227 * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 * if isinstance(name, string_types): * try: # <<<<<<<<<<<<<< * name = bytes(name, 'utf-8') # Python 3 * except TypeError: */ } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":229 * try: * name = bytes(name, 'utf-8') # Python 3 * except TypeError: # <<<<<<<<<<<<<< * name = name.encode('utf-8') # Python 2 * */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_8) { __Pyx_AddTraceback("rtmidi._rtmidi._to_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 229, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); /* "src/_rtmidi.pyx":230 * name = bytes(name, 'utf-8') # Python 3 * except TypeError: * name = name.encode('utf-8') # Python 2 # <<<<<<<<<<<<<< * * if not isinstance(name, bytes): */ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 230, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_kp_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_kp_u_utf_8); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 230, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/_rtmidi.pyx":227 * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 * if isinstance(name, string_types): * try: # <<<<<<<<<<<<<< * name = bytes(name, 'utf-8') # Python 3 * except TypeError: */ __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); __pyx_L9_try_end:; } /* "src/_rtmidi.pyx":226 * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 * if isinstance(name, string_types): # <<<<<<<<<<<<<< * try: * name = bytes(name, 'utf-8') # Python 3 */ } /* "src/_rtmidi.pyx":232 * name = name.encode('utf-8') # Python 2 * * if not isinstance(name, bytes): # <<<<<<<<<<<<<< * raise TypeError("name must be bytes or (unicode) string.") * */ __pyx_t_3 = PyBytes_Check(__pyx_v_name); __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "src/_rtmidi.pyx":233 * * if not isinstance(name, bytes): * raise TypeError("name must be bytes or (unicode) string.") # <<<<<<<<<<<<<< * * return name */ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __PYX_ERR(0, 233, __pyx_L1_error) /* "src/_rtmidi.pyx":232 * name = name.encode('utf-8') # Python 2 * * if not isinstance(name, bytes): # <<<<<<<<<<<<<< * raise TypeError("name must be bytes or (unicode) string.") * */ } /* "src/_rtmidi.pyx":235 * raise TypeError("name must be bytes or (unicode) string.") * * return name # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_name); __pyx_r = __pyx_v_name; goto __pyx_L0; /* "src/_rtmidi.pyx":223 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("rtmidi._rtmidi._to_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":277 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_11RtMidiError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_11RtMidiError___init__[] = "RtMidiError.__init__(self, msg, type=None)"; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_11RtMidiError_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_11RtMidiError_1__init__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_11RtMidiError___init__}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_11RtMidiError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_msg = 0; PyObject *__pyx_v_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_msg,&__pyx_n_s_type,0}; PyObject* values[3] = {0,0,0}; values[2] = ((PyObject *)((PyObject *)Py_None)); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 277, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_type); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 277, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_self = values[0]; __pyx_v_msg = values[1]; __pyx_v_type = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 277, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.RtMidiError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_11RtMidiError___init__(__pyx_self, __pyx_v_self, __pyx_v_msg, __pyx_v_type); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_11RtMidiError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_type) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/_rtmidi.pyx":278 * * def __init__(self, msg, type=None): * super().__init__(msg) # <<<<<<<<<<<<<< * self.type = self.type if type is None else type * */ __pyx_t_2 = __Pyx_CyFunction_GetClassObj(__pyx_self); if (!__pyx_t_2) { PyErr_SetString(PyExc_SystemError, "super(): empty __class__ cell"); __PYX_ERR(0, 278, __pyx_L1_error) } __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_INCREF(__pyx_v_self); __Pyx_GIVEREF(__pyx_v_self); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":279 * def __init__(self, msg, type=None): * super().__init__(msg) * self.type = self.type if type is None else type # <<<<<<<<<<<<<< * * */ __pyx_t_4 = (__pyx_v_type == Py_None); if ((__pyx_t_4 != 0)) { __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; } else { __Pyx_INCREF(__pyx_v_type); __pyx_t_1 = __pyx_v_type; } if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_type, __pyx_t_1) < 0) __PYX_ERR(0, 279, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":277 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.RtMidiError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":338 * # wrappers for RtMidi's static methods and classes * * def get_api_display_name(api): # <<<<<<<<<<<<<< * """Return the display name of a specified MIDI API. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_3get_api_display_name(PyObject *__pyx_self, PyObject *__pyx_v_api); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_2get_api_display_name[] = "get_api_display_name(api)\nReturn the display name of a specified MIDI API.\n\n This returns a long name used for display purposes.\n\n The ``api`` should be given as the one of ``API_*`` constants in the\n module namespace, e.g.::\n\n display_name = rtmidi.get_api_display_name(rtmidi.API_UNIX_JACK)\n\n If the API is unknown, this function will return the empty string.\n\n "; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_3get_api_display_name = {"get_api_display_name", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_3get_api_display_name, METH_O, __pyx_doc_6rtmidi_7_rtmidi_2get_api_display_name}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_3get_api_display_name(PyObject *__pyx_self, PyObject *__pyx_v_api) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_api_display_name (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_2get_api_display_name(__pyx_self, ((PyObject *)__pyx_v_api)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_2get_api_display_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations enum RtMidi::Api __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_api_display_name", 0); /* "src/_rtmidi.pyx":351 * * """ * return RtMidi_getApiDisplayName(api).decode('utf-8') # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((enum RtMidi::Api)__Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(__pyx_v_api)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 351, __pyx_L1_error) __pyx_t_2 = __Pyx_decode_cpp_string(RtMidi::getApiDisplayName(__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":338 * # wrappers for RtMidi's static methods and classes * * def get_api_display_name(api): # <<<<<<<<<<<<<< * """Return the display name of a specified MIDI API. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("rtmidi._rtmidi.get_api_display_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":354 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_5get_api_name(PyObject *__pyx_self, PyObject *__pyx_v_api); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_4get_api_name[] = "get_api_name(api)\nReturn the name of a specified MIDI API.\n\n This returns a short lower-case name used for identification purposes.\n\n The ``api`` should be given as the one of ``API_*`` constants in the\n module namespace, e.g.::\n\n name = rtmidi.get_api_name(rtmidi.API_UNIX_JACK)\n\n If the API is unknown, this function will return the empty string.\n\n "; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_5get_api_name = {"get_api_name", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_5get_api_name, METH_O, __pyx_doc_6rtmidi_7_rtmidi_4get_api_name}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_5get_api_name(PyObject *__pyx_self, PyObject *__pyx_v_api) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_api_name (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_4get_api_name(__pyx_self, ((PyObject *)__pyx_v_api)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_4get_api_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations enum RtMidi::Api __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_api_name", 0); /* "src/_rtmidi.pyx":367 * * """ * return RtMidi_getApiName(api).decode('utf-8') # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((enum RtMidi::Api)__Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(__pyx_v_api)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 367, __pyx_L1_error) __pyx_t_2 = __Pyx_decode_cpp_string(RtMidi::getApiName(__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":354 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("rtmidi._rtmidi.get_api_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":370 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7get_compiled_api(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6get_compiled_api[] = "get_compiled_api()\nReturn a list of low-level MIDI backend APIs this module supports.\n\n Check for support for a particular API by using the ``API_*`` constants in\n the module namespace, i.e.::\n\n if rtmidi.API_UNIX_JACK in rtmidi.get_compiled_api():\n ...\n\n "; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_7get_compiled_api = {"get_compiled_api", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7get_compiled_api, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6get_compiled_api}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7get_compiled_api(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_compiled_api (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6get_compiled_api(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6get_compiled_api(CYTHON_UNUSED PyObject *__pyx_self) { std::vector __pyx_v_api_v; std::vector ::size_type __pyx_8genexpr1__pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; std::vector ::size_type __pyx_t_2; std::vector ::size_type __pyx_t_3; std::vector ::size_type __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_compiled_api", 0); /* "src/_rtmidi.pyx":382 * cdef vector[Api] api_v * * RtMidi_getCompiledApi(api_v) # <<<<<<<<<<<<<< * return [api_v[i] for i in range(api_v.size())] * */ RtMidi::getCompiledApi(__pyx_v_api_v); /* "src/_rtmidi.pyx":383 * * RtMidi_getCompiledApi(api_v) * return [api_v[i] for i in range(api_v.size())] # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); { /* enter inner scope */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_v_api_v.size(); __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_8genexpr1__pyx_v_i = __pyx_t_4; __pyx_t_5 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api((__pyx_v_api_v[__pyx_8genexpr1__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } } /* exit inner scope */ __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":370 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("rtmidi._rtmidi.get_compiled_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":386 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_9get_compiled_api_by_name(PyObject *__pyx_self, PyObject *__pyx_v_name); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8get_compiled_api_by_name[] = "get_compiled_api_by_name(name)\nReturn the compiled MIDI API having the given name.\n\n A case insensitive comparison will check the specified name against the\n list of compiled APIs, and return the one which matches. On failure, the\n function returns ``API_UNSPECIFIED``.\n\n "; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_9get_compiled_api_by_name = {"get_compiled_api_by_name", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_9get_compiled_api_by_name, METH_O, __pyx_doc_6rtmidi_7_rtmidi_8get_compiled_api_by_name}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_9get_compiled_api_by_name(PyObject *__pyx_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_compiled_api_by_name (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8get_compiled_api_by_name(__pyx_self, ((PyObject *)__pyx_v_name)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8get_compiled_api_by_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; std::string __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_compiled_api_by_name", 0); /* "src/_rtmidi.pyx":394 * * """ * return RtMidi_getCompiledApiByName(_to_bytes(name)) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::getCompiledApiByName(__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":386 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.get_compiled_api_by_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":397 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_11get_rtmidi_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_10get_rtmidi_version[] = "get_rtmidi_version()\nReturn the version string of the wrapped RtMidi library."; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_11get_rtmidi_version = {"get_rtmidi_version", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_11get_rtmidi_version, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_10get_rtmidi_version}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_11get_rtmidi_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_rtmidi_version (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_10get_rtmidi_version(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_10get_rtmidi_version(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_rtmidi_version", 0); /* "src/_rtmidi.pyx":399 * def get_rtmidi_version(): * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_decode_cpp_string(RtMidi::getVersion(), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":397 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.get_rtmidi_version", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":402 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_13_default_error_handler(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_12_default_error_handler[] = "_default_error_handler(etype, msg, data=None)"; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_13_default_error_handler = {"_default_error_handler", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_13_default_error_handler, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_12_default_error_handler}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_13_default_error_handler(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_etype = 0; PyObject *__pyx_v_msg = 0; CYTHON_UNUSED PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_default_error_handler (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_msg,&__pyx_n_s_data,0}; PyObject* values[3] = {0,0,0}; values[2] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_default_error_handler", 0, 2, 3, 1); __PYX_ERR(0, 402, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_default_error_handler") < 0)) __PYX_ERR(0, 402, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_etype = values[0]; __pyx_v_msg = values[1]; __pyx_v_data = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_default_error_handler", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 402, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi._default_error_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_12_default_error_handler(__pyx_self, __pyx_v_etype, __pyx_v_msg, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_12_default_error_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_etype, PyObject *__pyx_v_msg, CYTHON_UNUSED PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_default_error_handler", 0); /* "src/_rtmidi.pyx":403 * * def _default_error_handler(etype, msg, data=None): * if etype == ERR_MEMORY_ERROR: # <<<<<<<<<<<<<< * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::MEMORY_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_RichCompare(__pyx_v_etype, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 403, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":404 * def _default_error_handler(etype, msg, data=None): * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) # <<<<<<<<<<<<<< * elif etype == ERR_INVALID_PARAMETER: * raise InvalidPortError(msg) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MemoryAllocationError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 404, __pyx_L1_error) /* "src/_rtmidi.pyx":403 * * def _default_error_handler(etype, msg, data=None): * if etype == ERR_MEMORY_ERROR: # <<<<<<<<<<<<<< * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: */ } /* "src/_rtmidi.pyx":405 * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_PARAMETER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyObject_RichCompare(__pyx_v_etype, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":406 * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: * raise InvalidPortError(msg) # <<<<<<<<<<<<<< * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): * raise SystemError(msg, type=etype) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_InvalidPortError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 406, __pyx_L1_error) /* "src/_rtmidi.pyx":405 * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): */ } /* "src/_rtmidi.pyx":407 * elif etype == ERR_INVALID_PARAMETER: * raise InvalidPortError(msg) * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): # <<<<<<<<<<<<<< * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): */ __Pyx_INCREF(__pyx_v_etype); __pyx_t_1 = __pyx_v_etype; __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::SYSTEM_ERROR); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::THREAD_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __pyx_t_5; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_3 != 0); if (unlikely(__pyx_t_5)) { /* "src/_rtmidi.pyx":408 * raise InvalidPortError(msg) * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): * raise SystemError(msg, type=etype) # <<<<<<<<<<<<<< * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): * if 'portNumber' in msg and msg.endswith('is invalid.'): */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_type, __pyx_v_etype) < 0) __PYX_ERR(0, 408, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 408, __pyx_L1_error) /* "src/_rtmidi.pyx":407 * elif etype == ERR_INVALID_PARAMETER: * raise InvalidPortError(msg) * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): # <<<<<<<<<<<<<< * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): */ } /* "src/_rtmidi.pyx":409 * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): # <<<<<<<<<<<<<< * if 'portNumber' in msg and msg.endswith('is invalid.'): * raise InvalidPortError(msg) */ __Pyx_INCREF(__pyx_v_etype); __pyx_t_6 = __pyx_v_etype; __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::WARNING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_3) { } else { __pyx_t_5 = __pyx_t_3; goto __pyx_L7_bool_binop_done; } __pyx_t_4 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DEBUG_WARNING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __pyx_t_3; __pyx_L7_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__pyx_t_5 != 0); if (__pyx_t_3) { /* "src/_rtmidi.pyx":410 * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): * if 'portNumber' in msg and msg.endswith('is invalid.'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('no ports available!'): */ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_portNumber, __pyx_v_msg, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 410, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (__pyx_t_7) { } else { __pyx_t_3 = __pyx_t_7; goto __pyx_L10_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_is_invalid) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_is_invalid); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = __pyx_t_7; __pyx_L10_bool_binop_done:; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":411 * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): * if 'portNumber' in msg and msg.endswith('is invalid.'): * raise InvalidPortError(msg) # <<<<<<<<<<<<<< * elif msg.endswith('no ports available!'): * raise InvalidPortError(msg) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_InvalidPortError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 411, __pyx_L1_error) /* "src/_rtmidi.pyx":410 * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): * if 'portNumber' in msg and msg.endswith('is invalid.'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('no ports available!'): */ } /* "src/_rtmidi.pyx":412 * if 'portNumber' in msg and msg.endswith('is invalid.'): * raise InvalidPortError(msg) * elif msg.endswith('no ports available!'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('error looking for port name!'): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_no_ports_available) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_no_ports_available); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":413 * raise InvalidPortError(msg) * elif msg.endswith('no ports available!'): * raise InvalidPortError(msg) # <<<<<<<<<<<<<< * elif msg.endswith('error looking for port name!'): * raise InvalidPortError(msg) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_InvalidPortError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 413, __pyx_L1_error) /* "src/_rtmidi.pyx":412 * if 'portNumber' in msg and msg.endswith('is invalid.'): * raise InvalidPortError(msg) * elif msg.endswith('no ports available!'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('error looking for port name!'): */ } /* "src/_rtmidi.pyx":414 * elif msg.endswith('no ports available!'): * raise InvalidPortError(msg) * elif msg.endswith('error looking for port name!'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('event parsing error!'): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_error_looking_for_port_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_error_looking_for_port_name); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":415 * raise InvalidPortError(msg) * elif msg.endswith('error looking for port name!'): * raise InvalidPortError(msg) # <<<<<<<<<<<<<< * elif msg.endswith('event parsing error!'): * raise ValueError(msg) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_InvalidPortError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 415, __pyx_L1_error) /* "src/_rtmidi.pyx":414 * elif msg.endswith('no ports available!'): * raise InvalidPortError(msg) * elif msg.endswith('error looking for port name!'): # <<<<<<<<<<<<<< * raise InvalidPortError(msg) * elif msg.endswith('event parsing error!'): */ } /* "src/_rtmidi.pyx":416 * elif msg.endswith('error looking for port name!'): * raise InvalidPortError(msg) * elif msg.endswith('event parsing error!'): # <<<<<<<<<<<<<< * raise ValueError(msg) * elif msg.endswith('error sending MIDI message to port.'): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_event_parsing_error) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_event_parsing_error); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":417 * raise InvalidPortError(msg) * elif msg.endswith('event parsing error!'): * raise ValueError(msg) # <<<<<<<<<<<<<< * elif msg.endswith('error sending MIDI message to port.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) */ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_v_msg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 417, __pyx_L1_error) /* "src/_rtmidi.pyx":416 * elif msg.endswith('error looking for port name!'): * raise InvalidPortError(msg) * elif msg.endswith('event parsing error!'): # <<<<<<<<<<<<<< * raise ValueError(msg) * elif msg.endswith('error sending MIDI message to port.'): */ } /* "src/_rtmidi.pyx":418 * elif msg.endswith('event parsing error!'): * raise ValueError(msg) * elif msg.endswith('error sending MIDI message to port.'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('error sending MIDI to virtual destinations.'): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_error_sending_MIDI_message_to_po) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_error_sending_MIDI_message_to_po); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":419 * raise ValueError(msg) * elif msg.endswith('error sending MIDI message to port.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) # <<<<<<<<<<<<<< * elif msg.endswith('error sending MIDI to virtual destinations.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_t_1) < 0) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 419, __pyx_L1_error) /* "src/_rtmidi.pyx":418 * elif msg.endswith('event parsing error!'): * raise ValueError(msg) * elif msg.endswith('error sending MIDI message to port.'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('error sending MIDI to virtual destinations.'): */ } /* "src/_rtmidi.pyx":420 * elif msg.endswith('error sending MIDI message to port.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('error sending MIDI to virtual destinations.'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('JACK server not running?'): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_kp_u_error_sending_MIDI_to_virtual_de) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_error_sending_MIDI_to_virtual_de); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 420, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":421 * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('error sending MIDI to virtual destinations.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) # <<<<<<<<<<<<<< * elif msg.endswith('JACK server not running?'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_type, __pyx_t_6) < 0) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 421, __pyx_L1_error) /* "src/_rtmidi.pyx":420 * elif msg.endswith('error sending MIDI message to port.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('error sending MIDI to virtual destinations.'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('JACK server not running?'): */ } /* "src/_rtmidi.pyx":422 * elif msg.endswith('error sending MIDI to virtual destinations.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('JACK server not running?'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * else: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_endswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_JACK_server_not_running) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_JACK_server_not_running); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 422, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { /* "src/_rtmidi.pyx":423 * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('JACK server not running?'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) # <<<<<<<<<<<<<< * else: * warnings.warn(msg) */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_t_1) < 0) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 423, __pyx_L1_error) /* "src/_rtmidi.pyx":422 * elif msg.endswith('error sending MIDI to virtual destinations.'): * raise SystemError(msg, type=ERR_DRIVER_ERROR) * elif msg.endswith('JACK server not running?'): # <<<<<<<<<<<<<< * raise SystemError(msg, type=ERR_DRIVER_ERROR) * else: */ } /* "src/_rtmidi.pyx":425 * raise SystemError(msg, type=ERR_DRIVER_ERROR) * else: * warnings.warn(msg) # <<<<<<<<<<<<<< * return * */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_warnings); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_msg); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":426 * else: * warnings.warn(msg) * return # <<<<<<<<<<<<<< * * raise RtMidiError(msg, type=etype) */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/_rtmidi.pyx":409 * elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): * raise SystemError(msg, type=etype) * elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): # <<<<<<<<<<<<<< * if 'portNumber' in msg and msg.endswith('is invalid.'): * raise InvalidPortError(msg) */ } /* "src/_rtmidi.pyx":428 * return * * raise RtMidiError(msg, type=etype) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_v_etype) < 0) __PYX_ERR(0, 428, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 428, __pyx_L1_error) /* "src/_rtmidi.pyx":402 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("rtmidi._rtmidi._default_error_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":436 * cdef object _deleted * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return NULL * */ static RtMidi *__pyx_f_6rtmidi_7_rtmidi_8MidiBase_baseptr(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { RtMidi *__pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("baseptr", 0); /* "src/_rtmidi.pyx":437 * * cdef RtMidi* baseptr(self): * return NULL # <<<<<<<<<<<<<< * * # context management */ __pyx_r = NULL; goto __pyx_L0; /* "src/_rtmidi.pyx":436 * cdef object _deleted * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return NULL * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":440 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_1__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase___enter__[] = "MidiBase.__enter__(self)\nSupport context manager protocol.\n\n This means you can use ``MidiIn`` / ``MidiOut`` instances like this:\n\n :\n\n midiout = MidiIn()\n midiout.open_port(0)\n\n with midiout:\n midiout.send_message([...])\n\n and ``midiout.close_port()`` will be called automatically when exiting\n the ``with`` block.\n\n Since ``open_port()`` also returns the instance, you can even do:\n\n :\n\n midiout = MidiIn()\n\n with midiout.open_port(0):\n midiout.send_message([...])\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_1__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase___enter__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase___enter__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__", 0); /* "src/_rtmidi.pyx":466 * * """ * return self # <<<<<<<<<<<<<< * * def __exit__(self, *exc_info): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "src/_rtmidi.pyx":440 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":468 * return self * * def __exit__(self, *exc_info): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_3__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_2__exit__[] = "MidiBase.__exit__(self, *exc_info)\nSupport context manager protocol.\n\n This method is called when using a ``MidiIn`` / ``MidiOut`` instance as\n a context manager and closes open ports when exiting the ``with`` block.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_3__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_exc_info = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_exc_info = __pyx_args; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_2__exit__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_exc_info); /* function exit code */ __Pyx_XDECREF(__pyx_v_exc_info); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_2__exit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_info) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/_rtmidi.pyx":475 * * """ * self.close_port() # <<<<<<<<<<<<<< * * def _check_port(self): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_close_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":468 * return self * * def __exit__(self, *exc_info): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":477 * self.close_port() * * def _check_port(self): # <<<<<<<<<<<<<< * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_5_check_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_4_check_port[] = "MidiBase._check_port(self)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_5_check_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_check_port (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_4_check_port(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_4_check_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_v_inout = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; Py_UCS4 __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_check_port", 0); /* "src/_rtmidi.pyx":478 * * def _check_port(self): * inout = "input" if isinstance(self, MidiIn) else "output" # <<<<<<<<<<<<<< * if self._port == -1: * raise InvalidUseError("%r already opened virtual %s port." % */ __pyx_t_2 = __Pyx_TypeCheck(((PyObject *)__pyx_v_self), __pyx_ptype_6rtmidi_7_rtmidi_MidiIn); if ((__pyx_t_2 != 0)) { __Pyx_INCREF(__pyx_n_u_input); __pyx_t_1 = __pyx_n_u_input; } else { __Pyx_INCREF(__pyx_n_u_output); __pyx_t_1 = __pyx_n_u_output; } __pyx_v_inout = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":479 * def _check_port(self): * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: # <<<<<<<<<<<<<< * raise InvalidUseError("%r already opened virtual %s port." % * (self, inout)) */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_self->_port, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_2)) { /* "src/_rtmidi.pyx":480 * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: * raise InvalidUseError("%r already opened virtual %s port." % # <<<<<<<<<<<<<< * (self, inout)) * elif self._port is not None: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_InvalidUseError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = 127; /* "src/_rtmidi.pyx":481 * if self._port == -1: * raise InvalidUseError("%r already opened virtual %s port." % * (self, inout)) # <<<<<<<<<<<<<< * elif self._port is not None: * raise InvalidUseError("%r already opened %s port %i." % */ __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(((PyObject *)__pyx_v_self)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_already_opened_virtual); __pyx_t_5 += 24; __Pyx_GIVEREF(__pyx_kp_u_already_opened_virtual); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_kp_u_already_opened_virtual); __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_inout); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_port); __pyx_t_5 += 6; __Pyx_GIVEREF(__pyx_kp_u_port); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_kp_u_port); /* "src/_rtmidi.pyx":480 * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: * raise InvalidUseError("%r already opened virtual %s port." % # <<<<<<<<<<<<<< * (self, inout)) * elif self._port is not None: */ __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 4, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 480, __pyx_L1_error) /* "src/_rtmidi.pyx":479 * def _check_port(self): * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: # <<<<<<<<<<<<<< * raise InvalidUseError("%r already opened virtual %s port." % * (self, inout)) */ } /* "src/_rtmidi.pyx":482 * raise InvalidUseError("%r already opened virtual %s port." % * (self, inout)) * elif self._port is not None: # <<<<<<<<<<<<<< * raise InvalidUseError("%r already opened %s port %i." % * (self, inout, self._port)) */ __pyx_t_2 = (__pyx_v_self->_port != Py_None); __pyx_t_8 = (__pyx_t_2 != 0); if (unlikely(__pyx_t_8)) { /* "src/_rtmidi.pyx":483 * (self, inout)) * elif self._port is not None: * raise InvalidUseError("%r already opened %s port %i." % # <<<<<<<<<<<<<< * (self, inout, self._port)) * return inout */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_InvalidUseError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "src/_rtmidi.pyx":484 * elif self._port is not None: * raise InvalidUseError("%r already opened %s port %i." % * (self, inout, self._port)) # <<<<<<<<<<<<<< * return inout * */ __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_v_self)); __Pyx_INCREF(__pyx_v_inout); __Pyx_GIVEREF(__pyx_v_inout); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_inout); __Pyx_INCREF(__pyx_v_self->_port); __Pyx_GIVEREF(__pyx_v_self->_port); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_self->_port); /* "src/_rtmidi.pyx":483 * (self, inout)) * elif self._port is not None: * raise InvalidUseError("%r already opened %s port %i." % # <<<<<<<<<<<<<< * (self, inout, self._port)) * return inout */ __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_r_already_opened_s_port_i, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 483, __pyx_L1_error) /* "src/_rtmidi.pyx":482 * raise InvalidUseError("%r already opened virtual %s port." % * (self, inout)) * elif self._port is not None: # <<<<<<<<<<<<<< * raise InvalidUseError("%r already opened %s port %i." % * (self, inout, self._port)) */ } /* "src/_rtmidi.pyx":485 * raise InvalidUseError("%r already opened %s port %i." % * (self, inout, self._port)) * return inout # <<<<<<<<<<<<<< * * def _decode_string(self, s, encoding='auto'): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_inout); __pyx_r = __pyx_v_inout; goto __pyx_L0; /* "src/_rtmidi.pyx":477 * self.close_port() * * def _check_port(self): # <<<<<<<<<<<<<< * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase._check_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_inout); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":487 * return inout * * def _decode_string(self, s, encoding='auto'): # <<<<<<<<<<<<<< * """Decode given byte string with given encoding.""" * if encoding == 'auto': */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_7_decode_string(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_6_decode_string[] = "MidiBase._decode_string(self, s, encoding=u'auto')\nDecode given byte string with given encoding."; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_7_decode_string(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_s = 0; PyObject *__pyx_v_encoding = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_decode_string (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,&__pyx_n_s_encoding,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)__pyx_n_u_auto); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_s)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_encoding); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_decode_string") < 0)) __PYX_ERR(0, 487, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_s = values[0]; __pyx_v_encoding = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_decode_string", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 487, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase._decode_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_6_decode_string(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_s, __pyx_v_encoding); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_6_decode_string(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_encoding) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_decode_string", 0); __Pyx_INCREF(__pyx_v_encoding); /* "src/_rtmidi.pyx":489 * def _decode_string(self, s, encoding='auto'): * """Decode given byte string with given encoding.""" * if encoding == 'auto': # <<<<<<<<<<<<<< * if sys.platform.startswith('win'): * encoding = 'latin1' */ __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_encoding, __pyx_n_u_auto, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 489, __pyx_L1_error) if (__pyx_t_1) { /* "src/_rtmidi.pyx":490 * """Decode given byte string with given encoding.""" * if encoding == 'auto': * if sys.platform.startswith('win'): # <<<<<<<<<<<<<< * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_platform); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_u_win) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_u_win); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { /* "src/_rtmidi.pyx":491 * if encoding == 'auto': * if sys.platform.startswith('win'): * encoding = 'latin1' # <<<<<<<<<<<<<< * elif (self.get_current_api() == API_MACOSX_CORE and * sys.platform == 'darwin'): */ __Pyx_INCREF(__pyx_n_u_latin1); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_n_u_latin1); /* "src/_rtmidi.pyx":490 * """Decode given byte string with given encoding.""" * if encoding == 'auto': * if sys.platform.startswith('win'): # <<<<<<<<<<<<<< * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and */ goto __pyx_L4; } /* "src/_rtmidi.pyx":492 * if sys.platform.startswith('win'): * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and # <<<<<<<<<<<<<< * sys.platform == 'darwin'): * encoding = 'macroman' */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_current_api); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_API_MACOSX_CORE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L5_bool_binop_done; } /* "src/_rtmidi.pyx":493 * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and * sys.platform == 'darwin'): # <<<<<<<<<<<<<< * encoding = 'macroman' * else: */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_platform); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_darwin, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 493, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L5_bool_binop_done:; /* "src/_rtmidi.pyx":492 * if sys.platform.startswith('win'): * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and # <<<<<<<<<<<<<< * sys.platform == 'darwin'): * encoding = 'macroman' */ if (__pyx_t_1) { /* "src/_rtmidi.pyx":494 * elif (self.get_current_api() == API_MACOSX_CORE and * sys.platform == 'darwin'): * encoding = 'macroman' # <<<<<<<<<<<<<< * else: * encoding = 'utf-8' */ __Pyx_INCREF(__pyx_n_u_macroman); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_n_u_macroman); /* "src/_rtmidi.pyx":492 * if sys.platform.startswith('win'): * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and # <<<<<<<<<<<<<< * sys.platform == 'darwin'): * encoding = 'macroman' */ goto __pyx_L4; } /* "src/_rtmidi.pyx":496 * encoding = 'macroman' * else: * encoding = 'utf-8' # <<<<<<<<<<<<<< * * return s.decode(encoding, "ignore") */ /*else*/ { __Pyx_INCREF(__pyx_kp_u_utf_8); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_8); } __pyx_L4:; /* "src/_rtmidi.pyx":489 * def _decode_string(self, s, encoding='auto'): * """Decode given byte string with given encoding.""" * if encoding == 'auto': # <<<<<<<<<<<<<< * if sys.platform.startswith('win'): * encoding = 'latin1' */ } /* "src/_rtmidi.pyx":498 * encoding = 'utf-8' * * return s.decode(encoding, "ignore") # <<<<<<<<<<<<<< * * def get_port_count(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_encoding, __pyx_n_u_ignore}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_encoding, __pyx_n_u_ignore}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(__pyx_v_encoding); __Pyx_GIVEREF(__pyx_v_encoding); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_encoding); __Pyx_INCREF(__pyx_n_u_ignore); __Pyx_GIVEREF(__pyx_n_u_ignore); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_ignore); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":487 * return inout * * def _decode_string(self, s, encoding='auto'): # <<<<<<<<<<<<<< * """Decode given byte string with given encoding.""" * if encoding == 'auto': */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase._decode_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_encoding); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":500 * return s.decode(encoding, "ignore") * * def get_port_count(self): # <<<<<<<<<<<<<< * """Return the number of available MIDI input or output ports.""" * return self.baseptr().getPortCount() */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_9get_port_count(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_8get_port_count[] = "MidiBase.get_port_count(self)\nReturn the number of available MIDI input or output ports."; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_9get_port_count(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_port_count (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_8get_port_count(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_8get_port_count(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations unsigned int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port_count", 0); /* "src/_rtmidi.pyx":502 * def get_port_count(self): * """Return the number of available MIDI input or output ports.""" * return self.baseptr().getPortCount() # <<<<<<<<<<<<<< * * def get_port_name(self, unsigned int port, encoding='auto'): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->getPortCount(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":500 * return s.decode(encoding, "ignore") * * def get_port_count(self): # <<<<<<<<<<<<<< * """Return the number of available MIDI input or output ports.""" * return self.baseptr().getPortCount() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.get_port_count", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":504 * return self.baseptr().getPortCount() * * def get_port_name(self, unsigned int port, encoding='auto'): # <<<<<<<<<<<<<< * """Return the name of the MIDI input or output port with given number. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_11get_port_name(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_10get_port_name[] = "MidiBase.get_port_name(self, unsigned int port, encoding=u'auto')\nReturn the name of the MIDI input or output port with given number.\n\n Ports are numbered from zero, separately for input and output ports.\n The number of available ports is returned by the ``get_port_count``\n method.\n\n The port name is decoded to a (unicode) string with the encoding given\n by ``encoding``. If ``encoding`` is ``\"auto\"`` (the default), then an\n appropriate encoding is chosen based on the system and the used backend\n API. If ``encoding`` is ``None``, the name is returned un-decoded, i.e.\n as type ``str`` in Python 2 or ``bytes`` in Python 3.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_11get_port_name(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { unsigned int __pyx_v_port; PyObject *__pyx_v_encoding = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_port_name (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port_2,&__pyx_n_s_encoding,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)__pyx_n_u_auto); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port_2)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_encoding); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_port_name") < 0)) __PYX_ERR(0, 504, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_port = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_port == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L3_error) __pyx_v_encoding = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_port_name", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 504, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.get_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_10get_port_name(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_port, __pyx_v_encoding); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_10get_port_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_encoding) { std::string __pyx_v_name; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port_name", 0); /* "src/_rtmidi.pyx":518 * * """ * cdef string name = self.baseptr().getPortName(port) # <<<<<<<<<<<<<< * * if len(name): */ __pyx_t_1 = ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->getPortName(__pyx_v_port); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error) __pyx_v_name = __pyx_t_1; /* "src/_rtmidi.pyx":520 * cdef string name = self.baseptr().getPortName(port) * * if len(name): # <<<<<<<<<<<<<< * return self._decode_string(name, encoding) if encoding else name * */ __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "src/_rtmidi.pyx":521 * * if len(name): * return self._decode_string(name, encoding) if encoding else name # <<<<<<<<<<<<<< * * def get_ports(self, encoding='auto'): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_encoding); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 521, __pyx_L1_error) if (__pyx_t_4) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_decode_string); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_encoding}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_encoding}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_v_encoding); __Pyx_GIVEREF(__pyx_v_encoding); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_encoding); __pyx_t_7 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = __pyx_t_5; __pyx_t_5 = 0; } else { __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __pyx_t_5; __pyx_t_5 = 0; } __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":520 * cdef string name = self.baseptr().getPortName(port) * * if len(name): # <<<<<<<<<<<<<< * return self._decode_string(name, encoding) if encoding else name * */ } /* "src/_rtmidi.pyx":504 * return self.baseptr().getPortCount() * * def get_port_name(self, unsigned int port, encoding='auto'): # <<<<<<<<<<<<<< * """Return the name of the MIDI input or output port with given number. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.get_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":523 * return self._decode_string(name, encoding) if encoding else name * * def get_ports(self, encoding='auto'): # <<<<<<<<<<<<<< * """Return a list of names of available MIDI input or output ports. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_13get_ports(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_12get_ports[] = "MidiBase.get_ports(self, encoding=u'auto')\nReturn a list of names of available MIDI input or output ports.\n\n The list index of each port name corresponds to its port number.\n\n The port names are decoded to (unicode) strings with the encoding given\n by ``encoding``. If ``encoding`` is ``\"auto\"`` (the default), then an\n appropriate encoding is chosen based on the system and the used backend\n API. If ``encoding`` is ``None``, the names are returned un-decoded,\n i.e. as type ``str`` in Python 2 or ``bytes`` in Python 3.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_13get_ports(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_encoding = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_ports (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_encoding,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)__pyx_n_u_auto); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_encoding); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_ports") < 0)) __PYX_ERR(0, 523, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_encoding = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_ports", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 523, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.get_ports", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_12get_ports(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_encoding); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_12get_ports(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_encoding) { PyObject *__pyx_8genexpr2__pyx_v_p = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_ports", 0); /* "src/_rtmidi.pyx":535 * * """ * return [self.get_port_name(p, encoding=encoding) # <<<<<<<<<<<<<< * for p in range(self.get_port_count())] * */ __Pyx_XDECREF(__pyx_r); { /* enter inner scope */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_1); /* "src/_rtmidi.pyx":536 * """ * return [self.get_port_name(p, encoding=encoding) * for p in range(self.get_port_count())] # <<<<<<<<<<<<<< * * def is_port_open(self): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_port_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 536, __pyx_L5_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 536, __pyx_L5_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 536, __pyx_L5_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_6(__pyx_t_2); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 536, __pyx_L5_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_p, __pyx_t_3); __pyx_t_3 = 0; /* "src/_rtmidi.pyx":535 * * """ * return [self.get_port_name(p, encoding=encoding) # <<<<<<<<<<<<<< * for p in range(self.get_port_count())] * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_port_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_8genexpr2__pyx_v_p); __Pyx_GIVEREF(__pyx_8genexpr2__pyx_v_p); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_8genexpr2__pyx_v_p); __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_encoding, __pyx_v_encoding) < 0) __PYX_ERR(0, 535, __pyx_L5_error) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 535, __pyx_L5_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/_rtmidi.pyx":536 * """ * return [self.get_port_name(p, encoding=encoding) * for p in range(self.get_port_count())] # <<<<<<<<<<<<<< * * def is_port_open(self): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_p); __pyx_8genexpr2__pyx_v_p = 0; goto __pyx_L8_exit_scope; __pyx_L5_error:; __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_p); __pyx_8genexpr2__pyx_v_p = 0; goto __pyx_L1_error; __pyx_L8_exit_scope:; } /* exit inner scope */ __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":523 * return self._decode_string(name, encoding) if encoding else name * * def get_ports(self, encoding='auto'): # <<<<<<<<<<<<<< * """Return a list of names of available MIDI input or output ports. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.get_ports", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_p); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":538 * for p in range(self.get_port_count())] * * def is_port_open(self): # <<<<<<<<<<<<<< * """Return ``True`` if a port has been opened and ``False`` if not. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_15is_port_open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_14is_port_open[] = "MidiBase.is_port_open(self)\nReturn ``True`` if a port has been opened and ``False`` if not.\n\n .. note::\n The ``isPortOpen`` method of the RtMidi C++ library does not\n return ``True`` when a virtual port has been openend. The\n python-rtmidi implementation, on the other hand, does.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_15is_port_open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_port_open (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_14is_port_open(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_14is_port_open(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_port_open", 0); /* "src/_rtmidi.pyx":547 * * """ * return self._port is not None # <<<<<<<<<<<<<< * * def open_port(self, unsigned int port=0, name=None): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = (__pyx_v_self->_port != Py_None); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":538 * for p in range(self.get_port_count())] * * def is_port_open(self): # <<<<<<<<<<<<<< * """Return ``True`` if a port has been opened and ``False`` if not. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.is_port_open", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":549 * return self._port is not None * * def open_port(self, unsigned int port=0, name=None): # <<<<<<<<<<<<<< * """Open the MIDI input or output port with the given port number. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_17open_port(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_16open_port[] = "MidiBase.open_port(self, unsigned int port=0, name=None)\nOpen the MIDI input or output port with the given port number.\n\n Only one port can be opened per ``MidiIn`` or ``MidiOut`` instance. An\n ``InvalidUseError`` exception is raised if an attempt is made to open a\n port on a ``MidiIn`` or ``MidiOut`` instance, which already opened a\n (virtual) port.\n\n You can optionally pass a name for the RtMidi port with the ``name``\n keyword or the second positional argument. Names with non-ASCII\n characters in them have to be passed as unicode or UTF-8 encoded\n strings in Python 2. The default name is \"RtMidi input\" resp. \"RtMidi\n output\".\n\n .. note::\n Closing a port and opening it again with a different name does not\n change the port name. To change the port name, use the\n ``set_port_name`` method where supported, or delete its instance,\n create a new one and open the port again giving a different name.\n\n Exceptions:\n\n ``InvalidPortError``\n Raised when an invalid port number is passed.\n ``InvalidUseError``\n Raised when trying to open a MIDI port when a (virtual) port has\n already been opened by this instance.\n ``TypeError``\n Raised when an incompatible value type is passed for the ``port``\n or ``name`` parameter.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_17open_port(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { unsigned int __pyx_v_port; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("open_port (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port_2,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port_2); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open_port") < 0)) __PYX_ERR(0, 549, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } if (values[0]) { __pyx_v_port = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_port == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L3_error) } else { __pyx_v_port = ((unsigned int)0); } __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("open_port", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 549, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.open_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_16open_port(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_port, __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_16open_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_name) { PyObject *__pyx_v_inout = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("open_port", 0); __Pyx_INCREF(__pyx_v_name); /* "src/_rtmidi.pyx":581 * * """ * inout = self._check_port() # <<<<<<<<<<<<<< * * if name is None: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_inout = __pyx_t_1; __pyx_t_1 = 0; /* "src/_rtmidi.pyx":583 * inout = self._check_port() * * if name is None: # <<<<<<<<<<<<<< * name = "RtMidi %s" % inout * */ __pyx_t_4 = (__pyx_v_name == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/_rtmidi.pyx":584 * * if name is None: * name = "RtMidi %s" % inout # <<<<<<<<<<<<<< * * self.baseptr().openPort(port, _to_bytes(name)) */ __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_RtMidi_s, __pyx_v_inout); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":583 * inout = self._check_port() * * if name is None: # <<<<<<<<<<<<<< * name = "RtMidi %s" % inout * */ } /* "src/_rtmidi.pyx":586 * name = "RtMidi %s" % inout * * self.baseptr().openPort(port, _to_bytes(name)) # <<<<<<<<<<<<<< * self._port = port * return self */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->openPort(__pyx_v_port, __pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 586, __pyx_L1_error) /* "src/_rtmidi.pyx":587 * * self.baseptr().openPort(port, _to_bytes(name)) * self._port = port # <<<<<<<<<<<<<< * return self * */ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_port); __Pyx_DECREF(__pyx_v_self->_port); __pyx_v_self->_port = __pyx_t_1; __pyx_t_1 = 0; /* "src/_rtmidi.pyx":588 * self.baseptr().openPort(port, _to_bytes(name)) * self._port = port * return self # <<<<<<<<<<<<<< * * def open_virtual_port(self, name=None): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "src/_rtmidi.pyx":549 * return self._port is not None * * def open_port(self, unsigned int port=0, name=None): # <<<<<<<<<<<<<< * """Open the MIDI input or output port with the given port number. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.open_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_inout); __Pyx_XDECREF(__pyx_v_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":590 * return self * * def open_virtual_port(self, name=None): # <<<<<<<<<<<<<< * """Open a virtual MIDI input or output port. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_19open_virtual_port(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_18open_virtual_port[] = "MidiBase.open_virtual_port(self, name=None)\nOpen a virtual MIDI input or output port.\n\n Only one port can be opened per ``MidiIn`` or ``MidiOut`` instance. An\n ``InvalidUseError`` exception is raised if an attempt is made to open a\n port on a ``MidiIn`` or ``MidiOut`` instance, which already opened a\n (virtual) port.\n\n A virtual port is not connected to a physical MIDI device or system\n port when first opened. You can connect it to another MIDI output with\n the OS-dependent tools provided by the low-level MIDI framework, e.g.\n ``aconnect`` for ALSA, ``jack_connect`` for JACK, or the Audio & MIDI\n settings dialog for CoreMIDI.\n\n .. note::\n Virtual ports are not supported by some backend APIs, namely the\n Windows MultiMedia API. You can use special MIDI drivers like `MIDI\n Yoke`_ or loopMIDI_ to provide hardware-independent virtual MIDI\n ports as an alternative.\n\n You can optionally pass a name for the RtMidi port with the ``name``\n keyword or the second positional argument. Names with non-ASCII\n characters in them have to be passed as unicode or UTF-8 encoded\n strings in Python 2. The default name is \"RtMidi virtual input\" resp.\n \"RtMidi virtual output\".\n\n .. note::\n Closing a port and opening it again with a different name does not\n change the port name. To change the port name, use the\n ``set_port_name`` method where supported, or delete its instance,\n create a new one and open the port again giving a different name.\n\n Also, to close a virtual input port, you have to delete its\n ``MidiIn`` or ``MidiOut`` instance.\n\n Exceptions:\n\n ``InvalidUseError``\n Raised when trying to open a virtual port when a (virtual) port has\n already been opened by this instance.\n ``Typ""eError``\n Raised when an incompatible value type is passed for the ``name``\n parameter.\n ``UnsupportedOperationError``\n Raised when trying to open a virtual MIDI port with the Windows\n MultiMedia API, which doesn't support virtual ports.\n\n .. _midi yoke: http://www.midiox.com/myoke.htm\n .. _loopmidi: http://www.tobias-erichsen.de/software/loopmidi.html\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_19open_virtual_port(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("open_virtual_port (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open_virtual_port") < 0)) __PYX_ERR(0, 590, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_name = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("open_virtual_port", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 590, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.open_virtual_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_18open_virtual_port(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_18open_virtual_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_v_inout = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("open_virtual_port", 0); /* "src/_rtmidi.pyx":641 * * """ * if self.get_current_api() == API_WINDOWS_MM: # <<<<<<<<<<<<<< * raise NotImplementedError("Virtual ports are not supported " * "by the Windows MultiMedia API.") */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_current_api); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_API_WINDOWS_MM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { /* "src/_rtmidi.pyx":642 * """ * if self.get_current_api() == API_WINDOWS_MM: * raise NotImplementedError("Virtual ports are not supported " # <<<<<<<<<<<<<< * "by the Windows MultiMedia API.") * */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 642, __pyx_L1_error) /* "src/_rtmidi.pyx":641 * * """ * if self.get_current_api() == API_WINDOWS_MM: # <<<<<<<<<<<<<< * raise NotImplementedError("Virtual ports are not supported " * "by the Windows MultiMedia API.") */ } /* "src/_rtmidi.pyx":645 * "by the Windows MultiMedia API.") * * inout = self._check_port() # <<<<<<<<<<<<<< * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) * if name is None else name)) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_inout = __pyx_t_3; __pyx_t_3 = 0; /* "src/_rtmidi.pyx":646 * * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) # <<<<<<<<<<<<<< * if name is None else name)) * self._port = -1 */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "src/_rtmidi.pyx":647 * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) * if name is None else name)) # <<<<<<<<<<<<<< * self._port = -1 * return self */ __pyx_t_4 = (__pyx_v_name == Py_None); if ((__pyx_t_4 != 0)) { /* "src/_rtmidi.pyx":646 * * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) # <<<<<<<<<<<<<< * if name is None else name)) * self._port = -1 */ __pyx_t_5 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_RtMidi_virtual_s, __pyx_v_inout); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __pyx_t_5; __pyx_t_5 = 0; } else { /* "src/_rtmidi.pyx":647 * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) * if name is None else name)) # <<<<<<<<<<<<<< * self._port = -1 * return self */ __Pyx_INCREF(__pyx_v_name); __pyx_t_1 = __pyx_v_name; } __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/_rtmidi.pyx":646 * * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) # <<<<<<<<<<<<<< * if name is None else name)) * self._port = -1 */ __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->openVirtualPort(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) /* "src/_rtmidi.pyx":648 * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) * if name is None else name)) * self._port = -1 # <<<<<<<<<<<<<< * return self * */ __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); __Pyx_GOTREF(__pyx_v_self->_port); __Pyx_DECREF(__pyx_v_self->_port); __pyx_v_self->_port = __pyx_int_neg_1; /* "src/_rtmidi.pyx":649 * if name is None else name)) * self._port = -1 * return self # <<<<<<<<<<<<<< * * def close_port(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "src/_rtmidi.pyx":590 * return self * * def open_virtual_port(self, name=None): # <<<<<<<<<<<<<< * """Open a virtual MIDI input or output port. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.open_virtual_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_inout); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":651 * return self * * def close_port(self): # <<<<<<<<<<<<<< * """Close the MIDI input or output port opened via ``open_port``. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_21close_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_20close_port[] = "MidiBase.close_port(self)\nClose the MIDI input or output port opened via ``open_port``.\n\n It is safe to call this method repeatedly or if no port has been opened\n (yet) by this instance.\n\n Also cancels a callback function set with ``set_callback``.\n\n To close a virtual port opened via ``open_virtual_port``, you have to\n delete its ``MidiIn`` or ``MidiOut`` instance.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_21close_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close_port (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_20close_port(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_20close_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close_port", 0); /* "src/_rtmidi.pyx":663 * * """ * if self._port != -1: # <<<<<<<<<<<<<< * self._port = None * self.baseptr().closePort() */ __pyx_t_1 = __Pyx_PyInt_NeObjC(__pyx_v_self->_port, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 663, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "src/_rtmidi.pyx":664 * """ * if self._port != -1: * self._port = None # <<<<<<<<<<<<<< * self.baseptr().closePort() * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_port); __Pyx_DECREF(__pyx_v_self->_port); __pyx_v_self->_port = Py_None; /* "src/_rtmidi.pyx":663 * * """ * if self._port != -1: # <<<<<<<<<<<<<< * self._port = None * self.baseptr().closePort() */ } /* "src/_rtmidi.pyx":665 * if self._port != -1: * self._port = None * self.baseptr().closePort() # <<<<<<<<<<<<<< * * def set_client_name(self, name): */ ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->closePort(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 665, __pyx_L1_error) /* "src/_rtmidi.pyx":651 * return self * * def close_port(self): # <<<<<<<<<<<<<< * """Close the MIDI input or output port opened via ``open_port``. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.close_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":667 * self.baseptr().closePort() * * def set_client_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the MIDI client. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_23set_client_name(PyObject *__pyx_v_self, PyObject *__pyx_v_name); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_22set_client_name[] = "MidiBase.set_client_name(self, name)\nSet the name of the MIDI client.\n\n Names with non-ASCII characters in them have to be passed as unicode\n or UTF-8 encoded strings in Python 2.\n\n Currently only supported by the ALSA API backend.\n\n Exceptions:\n\n ``TypeError``\n Raised when an incompatible value type is passed for the ``name``\n parameter.\n ``UnsupportedOperationError``\n Raised when trying the backend API does not support changing the\n client name.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_23set_client_name(PyObject *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_client_name (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_22set_client_name(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), ((PyObject *)__pyx_v_name)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_22set_client_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_client_name", 0); /* "src/_rtmidi.pyx":685 * * """ * if self.get_current_api() in (API_MACOSX_CORE, API_UNIX_JACK, API_WINDOWS_MM): # <<<<<<<<<<<<<< * raise NotImplementedError( * "API backend does not support changing the client name.") */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_current_api); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_API_MACOSX_CORE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_API_UNIX_JACK); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_API_WINDOWS_MM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __pyx_t_5; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (unlikely(__pyx_t_5)) { /* "src/_rtmidi.pyx":686 * """ * if self.get_current_api() in (API_MACOSX_CORE, API_UNIX_JACK, API_WINDOWS_MM): * raise NotImplementedError( # <<<<<<<<<<<<<< * "API backend does not support changing the client name.") * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 686, __pyx_L1_error) /* "src/_rtmidi.pyx":685 * * """ * if self.get_current_api() in (API_MACOSX_CORE, API_UNIX_JACK, API_WINDOWS_MM): # <<<<<<<<<<<<<< * raise NotImplementedError( * "API backend does not support changing the client name.") */ } /* "src/_rtmidi.pyx":689 * "API backend does not support changing the client name.") * * self.baseptr().setClientName(_to_bytes(name)) # <<<<<<<<<<<<<< * * def set_port_name(self, name): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_name); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->setClientName(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L1_error) /* "src/_rtmidi.pyx":667 * self.baseptr().closePort() * * def set_client_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the MIDI client. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.set_client_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":691 * self.baseptr().setClientName(_to_bytes(name)) * * def set_port_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the currently opened port. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_25set_port_name(PyObject *__pyx_v_self, PyObject *__pyx_v_name); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_24set_port_name[] = "MidiBase.set_port_name(self, name)\nSet the name of the currently opened port.\n\n Names with non-ASCII characters in them have to be passed as unicode\n or UTF-8 encoded strings in Python 2.\n\n Currently only supported by the ALSA and JACK API backends.\n\n Exceptions:\n\n ``InvalidUseError``\n Raised when no port is currently opened.\n ``TypeError``\n Raised when an incompatible value type is passed for the ``name``\n parameter.\n ``UnsupportedOperationError``\n Raised when trying the backend API does not support changing the\n port name.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_25set_port_name(PyObject *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_port_name (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_24set_port_name(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), ((PyObject *)__pyx_v_name)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_24set_port_name(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_port_name", 0); /* "src/_rtmidi.pyx":711 * * """ * if self.get_current_api() in (API_MACOSX_CORE, API_WINDOWS_MM): # <<<<<<<<<<<<<< * raise UnsupportedOperationError( * "API backend does not support changing the port name.") */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_current_api); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_API_MACOSX_CORE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_API_WINDOWS_MM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __pyx_t_5; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (unlikely(__pyx_t_5)) { /* "src/_rtmidi.pyx":712 * """ * if self.get_current_api() in (API_MACOSX_CORE, API_WINDOWS_MM): * raise UnsupportedOperationError( # <<<<<<<<<<<<<< * "API backend does not support changing the port name.") * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_UnsupportedOperationError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 712, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_API_backend_does_not_support_cha_2) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_API_backend_does_not_support_cha_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 712, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 712, __pyx_L1_error) /* "src/_rtmidi.pyx":711 * * """ * if self.get_current_api() in (API_MACOSX_CORE, API_WINDOWS_MM): # <<<<<<<<<<<<<< * raise UnsupportedOperationError( * "API backend does not support changing the port name.") */ } /* "src/_rtmidi.pyx":715 * "API backend does not support changing the port name.") * * if self._port is None: # <<<<<<<<<<<<<< * raise InvalidUseError("No port currently opened.") * */ __pyx_t_5 = (__pyx_v_self->_port == Py_None); __pyx_t_4 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_4)) { /* "src/_rtmidi.pyx":716 * * if self._port is None: * raise InvalidUseError("No port currently opened.") # <<<<<<<<<<<<<< * * self.baseptr().setPortName(_to_bytes(name)) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_InvalidUseError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_No_port_currently_opened) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_No_port_currently_opened); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 716, __pyx_L1_error) /* "src/_rtmidi.pyx":715 * "API backend does not support changing the port name.") * * if self._port is None: # <<<<<<<<<<<<<< * raise InvalidUseError("No port currently opened.") * */ } /* "src/_rtmidi.pyx":718 * raise InvalidUseError("No port currently opened.") * * self.baseptr().setPortName(_to_bytes(name)) # <<<<<<<<<<<<<< * * def set_error_callback(self, func, data=None): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->setPortName(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 718, __pyx_L1_error) /* "src/_rtmidi.pyx":691 * self.baseptr().setClientName(_to_bytes(name)) * * def set_port_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the currently opened port. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.set_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":720 * self.baseptr().setPortName(_to_bytes(name)) * * def set_error_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for errors. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_27set_error_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_26set_error_callback[] = "MidiBase.set_error_callback(self, func, data=None)\nRegister a callback function for errors.\n\n The callback function is called when an error occurs and must take\n three arguments. The first argument is a member of enum\n ``RtMidiError::Type``, represented by one of the ``ERRORTYPE_*``\n constants. The second argument is an error message. The third argument\n is the value of the ``data`` argument passed to this function when the\n callback is registered.\n\n .. note::\n A default error handler function is registered on new instances of\n ``MidiIn`` and ``MidiOut``, which turns errors reported by the C++\n layer into custom exceptions derived from ``RtMidiError``.\n\n If you replace this default error handler, be aware that the\n exception handling in your code probably needs to be adapted.\n\n Registering an error callback function replaces any previously\n registered error callback, including the above mentioned default error\n handler.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_27set_error_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_func = 0; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_error_callback (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_func)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_error_callback") < 0)) __PYX_ERR(0, 720, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_func = values[0]; __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_error_callback", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 720, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.set_error_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_26set_error_callback(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_func, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_26set_error_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_error_callback", 0); /* "src/_rtmidi.pyx":743 * * """ * self._error_callback = (func, data, self._decode_string) # <<<<<<<<<<<<<< * self.baseptr().setErrorCallback(&_cb_error_func, * self._error_callback) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_decode_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_func); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_data); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->_error_callback); __Pyx_DECREF(__pyx_v_self->_error_callback); __pyx_v_self->_error_callback = __pyx_t_2; __pyx_t_2 = 0; /* "src/_rtmidi.pyx":744 * """ * self._error_callback = (func, data, self._decode_string) * self.baseptr().setErrorCallback(&_cb_error_func, # <<<<<<<<<<<<<< * self._error_callback) * */ ((struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self)->setErrorCallback((&__pyx_f_6rtmidi_7_rtmidi__cb_error_func), ((void *)__pyx_v_self->_error_callback)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 744, __pyx_L1_error) /* "src/_rtmidi.pyx":720 * self.baseptr().setPortName(_to_bytes(name)) * * def set_error_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for errors. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.set_error_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":747 * self._error_callback) * * def cancel_error_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for errors. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_29cancel_error_callback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_28cancel_error_callback[] = "MidiBase.cancel_error_callback(self)\nRemove the registered callback function for errors.\n\n This can be safely called even when no callback function has been\n registered and reinstates the default error handler.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_29cancel_error_callback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("cancel_error_callback (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_28cancel_error_callback(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_28cancel_error_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("cancel_error_callback", 0); /* "src/_rtmidi.pyx":754 * * """ * self.set_error_callback(_default_error_handler) # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_error_callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_default_error_handler); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":747 * self._error_callback) * * def cancel_error_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for errors. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.cancel_error_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_31__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_30__reduce_cython__[] = "MidiBase.__reduce_cython__(self)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_31__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_30__reduce_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_30__reduce_cython__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self._deleted, self._error_callback, self._port) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->_deleted); __Pyx_GIVEREF(__pyx_v_self->_deleted); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->_deleted); __Pyx_INCREF(__pyx_v_self->_error_callback); __Pyx_GIVEREF(__pyx_v_self->_error_callback); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->_error_callback); __Pyx_INCREF(__pyx_v_self->_port); __Pyx_GIVEREF(__pyx_v_self->_port); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->_port); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self._deleted, self._error_callback, self._port) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__dict = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":7 * state = (self._deleted, self._error_callback, self._port) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_2 = (__pyx_v__dict != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self._deleted is not None or self._error_callback is not None or self._port is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self._deleted, self._error_callback, self._port) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self._deleted is not None or self._error_callback is not None or self._port is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, None), state */ /*else*/ { __pyx_t_2 = (__pyx_v_self->_deleted != Py_None); __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (__pyx_v_self->_error_callback != Py_None); __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_self->_port != Py_None); __pyx_t_5 = (__pyx_t_2 != 0); __pyx_t_3 = __pyx_t_5; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_3; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self._deleted is not None or self._error_callback is not None or self._port is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, None), state * else: */ __pyx_t_3 = (__pyx_v_use_setstate != 0); if (__pyx_t_3) { /* "(tree fragment)":13 * use_setstate = self._deleted is not None or self._error_callback is not None or self._port is not None * if use_setstate: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_MidiBase); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_152509455); __Pyx_GIVEREF(__pyx_int_152509455); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_152509455); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self._deleted is not None or self._error_callback is not None or self._port is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, None), state * else: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pyx_unpickle_MidiBase); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_152509455); __Pyx_GIVEREF(__pyx_int_152509455); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_152509455); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_33__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_32__setstate_cython__[] = "MidiBase.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_33__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_8MidiBase_32__setstate_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_8MidiBase_32__setstate_cython__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_6rtmidi_7_rtmidi___pyx_unpickle_MidiBase__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_MidiBase, (type(self), 0x9171c0f, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiBase.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":801 * cdef object _callback * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ static RtMidi *__pyx_f_6rtmidi_7_rtmidi_6MidiIn_baseptr(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { RtMidi *__pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("baseptr", 0); /* "src/_rtmidi.pyx":802 * * cdef RtMidi* baseptr(self): * return self.thisptr # <<<<<<<<<<<<<< * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, */ __pyx_r = __pyx_v_self->thisptr; goto __pyx_L0; /* "src/_rtmidi.pyx":801 * cdef object _callback * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":804 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, # <<<<<<<<<<<<<< * unsigned int queue_size_limit=1024): * """Create a new client instance for MIDI input. */ /* Python wrapper */ static int __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { enum RtMidi::Api __pyx_v_rtapi; PyObject *__pyx_v_name = 0; unsigned int __pyx_v_queue_size_limit; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rtapi,&__pyx_n_s_name,&__pyx_n_s_queue_size_limit,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtapi); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_queue_size_limit); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 804, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } if (values[0]) { __pyx_v_rtapi = ((enum RtMidi::Api)__Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(values[0])); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 804, __pyx_L3_error) } else { __pyx_v_rtapi = __pyx_k__4; } __pyx_v_name = values[1]; if (values[2]) { __pyx_v_queue_size_limit = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_queue_size_limit == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 805, __pyx_L3_error) } else { __pyx_v_queue_size_limit = ((unsigned int)0x400); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 804, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn___cinit__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_rtapi, __pyx_v_name, __pyx_v_queue_size_limit); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6rtmidi_7_rtmidi_6MidiIn___cinit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, enum RtMidi::Api __pyx_v_rtapi, PyObject *__pyx_v_name, unsigned int __pyx_v_queue_size_limit) { PyObject *__pyx_v_exc = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; std::string __pyx_t_9; RtMidiIn *__pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_name); /* "src/_rtmidi.pyx":811 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiIn Client" * */ __pyx_t_1 = (__pyx_v_name == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":812 * """ * if name is None: * name = "RtMidiIn Client" # <<<<<<<<<<<<<< * * try: */ __Pyx_INCREF(__pyx_kp_u_RtMidiIn_Client); __Pyx_DECREF_SET(__pyx_v_name, __pyx_kp_u_RtMidiIn_Client); /* "src/_rtmidi.pyx":811 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiIn Client" * */ } /* "src/_rtmidi.pyx":814 * name = "RtMidiIn Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "src/_rtmidi.pyx":815 * * try: * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) # <<<<<<<<<<<<<< * except RuntimeError as exc: * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 815, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_name); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 815, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 815, __pyx_L4_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_t_10 = new RtMidiIn(__pyx_v_rtapi, __pyx_t_9, __pyx_v_queue_size_limit); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 815, __pyx_L4_error) } __pyx_v_self->thisptr = __pyx_t_10; /* "src/_rtmidi.pyx":814 * name = "RtMidiIn Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/_rtmidi.pyx":816 * try: * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: # <<<<<<<<<<<<<< * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * */ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_11) { __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 816, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_v_exc = __pyx_t_7; /*try:*/ { /* "src/_rtmidi.pyx":817 * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) # <<<<<<<<<<<<<< * * self.set_error_callback(_default_error_handler) */ __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_exc); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_15 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_15); if (PyDict_SetItem(__pyx_t_13, __pyx_n_s_type, __pyx_t_15) < 0) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 817, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_Raise(__pyx_t_15, 0, 0, 0); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __PYX_ERR(0, 817, __pyx_L15_error) } /* "src/_rtmidi.pyx":816 * try: * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: # <<<<<<<<<<<<<< * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * */ /*finally:*/ { __pyx_L15_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_11 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L6_except_error; } } } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/_rtmidi.pyx":814 * name = "RtMidiIn Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L9_try_end:; } /* "src/_rtmidi.pyx":819 * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * * self.set_error_callback(_default_error_handler) # <<<<<<<<<<<<<< * self._callback = None * self._port = None */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_error_callback); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_default_error_handler); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_15)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_8 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_15, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/_rtmidi.pyx":820 * * self.set_error_callback(_default_error_handler) * self._callback = None # <<<<<<<<<<<<<< * self._port = None * self._deleted = False */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_callback); __Pyx_DECREF(__pyx_v_self->_callback); __pyx_v_self->_callback = Py_None; /* "src/_rtmidi.pyx":821 * self.set_error_callback(_default_error_handler) * self._callback = None * self._port = None # <<<<<<<<<<<<<< * self._deleted = False * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->__pyx_base._port); __Pyx_DECREF(__pyx_v_self->__pyx_base._port); __pyx_v_self->__pyx_base._port = Py_None; /* "src/_rtmidi.pyx":822 * self._callback = None * self._port = None * self._deleted = False # <<<<<<<<<<<<<< * * def get_current_api(self): */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->__pyx_base._deleted); __Pyx_DECREF(__pyx_v_self->__pyx_base._deleted); __pyx_v_self->__pyx_base._deleted = Py_False; /* "src/_rtmidi.pyx":804 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, # <<<<<<<<<<<<<< * unsigned int queue_size_limit=1024): * """Create a new client instance for MIDI input. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_exc); __Pyx_XDECREF(__pyx_v_name); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":824 * self._deleted = False * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_3get_current_api(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_2get_current_api[] = "MidiIn.get_current_api(self)\nReturn the low-level MIDI backend API used by this instance.\n\n Use this by comparing the returned value to the module-level ``API_*``\n constants, e.g.::\n\n midiin = rtmidi.MidiIn()\n\n if midiin.get_current_api() == rtmidi.API_UNIX_JACK:\n print(\"Using JACK API for MIDI input.\")\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_3get_current_api(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_current_api (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_2get_current_api(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_2get_current_api(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_current_api", 0); /* "src/_rtmidi.pyx":836 * * """ * return self.thisptr.getCurrentApi() # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(__pyx_v_self->thisptr->getCurrentApi()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":824 * self._deleted = False * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.get_current_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":838 * return self.thisptr.getCurrentApi() * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* Python wrapper */ static void __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_5__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_4__dealloc__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_4__dealloc__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "src/_rtmidi.pyx":840 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ __pyx_t_1 = __Pyx_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_u_thisptr); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 840, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":841 * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): * del self.thisptr # <<<<<<<<<<<<<< * * def delete(self): */ delete __pyx_v_self->thisptr; /* "src/_rtmidi.pyx":840 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ } /* "src/_rtmidi.pyx":838 * return self.thisptr.getCurrentApi() * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("rtmidi._rtmidi.MidiIn.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "src/_rtmidi.pyx":843 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_7delete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_6delete[] = "MidiIn.delete(self)\nDe-allocate pointer to C++ class instance.\n\n .. warning:: the instance **must not** be used anymore after calling\n this method, otherwise the program will crash with a segmentation\n fault!\n\n The reason this potentially dangerous method exists is that in\n some cases it is desirable to destroy the internal ``RtMidiIn``\n C++ class instance with immediate effect, thereby closing the\n backend MIDI API client and all the ports it opened. By merely\n using ``del`` on the ``rtmidi.MidiIn`` Python instance, the\n destruction of the C++ instance may be delayed for an arbitrary\n amount of time, until the Python garbage collector cleans up the\n instance.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_7delete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_6delete(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_6delete(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("delete", 0); /* "src/_rtmidi.pyx":860 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->__pyx_base._deleted); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 860, __pyx_L1_error) __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":861 * """ * if not self._deleted: * del self.thisptr # <<<<<<<<<<<<<< * self._deleted = True * */ delete __pyx_v_self->thisptr; /* "src/_rtmidi.pyx":862 * if not self._deleted: * del self.thisptr * self._deleted = True # <<<<<<<<<<<<<< * * @property */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_v_self->__pyx_base._deleted); __Pyx_DECREF(__pyx_v_self->__pyx_base._deleted); __pyx_v_self->__pyx_base._deleted = Py_True; /* "src/_rtmidi.pyx":860 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ } /* "src/_rtmidi.pyx":843 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":865 * * @property * def is_deleted(self): # <<<<<<<<<<<<<< * return self._deleted * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_10is_deleted_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_10is_deleted_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10is_deleted___get__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10is_deleted___get__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "src/_rtmidi.pyx":866 * @property * def is_deleted(self): * return self._deleted # <<<<<<<<<<<<<< * * def cancel_callback(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->__pyx_base._deleted); __pyx_r = __pyx_v_self->__pyx_base._deleted; goto __pyx_L0; /* "src/_rtmidi.pyx":865 * * @property * def is_deleted(self): # <<<<<<<<<<<<<< * return self._deleted * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":868 * return self._deleted * * def cancel_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for MIDI input. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_9cancel_callback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_8cancel_callback[] = "MidiIn.cancel_callback(self)\nRemove the registered callback function for MIDI input.\n\n This can be safely called even when no callback function has been\n registered.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_9cancel_callback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("cancel_callback (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_8cancel_callback(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_8cancel_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("cancel_callback", 0); /* "src/_rtmidi.pyx":875 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.thisptr.cancelCallback() * self._callback = None */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_callback); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 875, __pyx_L1_error) if (__pyx_t_1) { /* "src/_rtmidi.pyx":876 * """ * if self._callback: * self.thisptr.cancelCallback() # <<<<<<<<<<<<<< * self._callback = None * */ __pyx_v_self->thisptr->cancelCallback(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 876, __pyx_L1_error) /* "src/_rtmidi.pyx":877 * if self._callback: * self.thisptr.cancelCallback() * self._callback = None # <<<<<<<<<<<<<< * * def close_port(self): */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_callback); __Pyx_DECREF(__pyx_v_self->_callback); __pyx_v_self->_callback = Py_None; /* "src/_rtmidi.pyx":875 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.thisptr.cancelCallback() * self._callback = None */ } /* "src/_rtmidi.pyx":868 * return self._deleted * * def cancel_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for MIDI input. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.cancel_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":879 * self._callback = None * * def close_port(self): # <<<<<<<<<<<<<< * self.cancel_callback() * MidiBase.close_port(self) */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_11close_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_10close_port[] = "MidiIn.close_port(self)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_11close_port(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close_port (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10close_port(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_10close_port(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close_port", 0); /* "src/_rtmidi.pyx":880 * * def close_port(self): * self.cancel_callback() # <<<<<<<<<<<<<< * MidiBase.close_port(self) * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cancel_callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":881 * def close_port(self): * self.cancel_callback() * MidiBase.close_port(self) # <<<<<<<<<<<<<< * * close_port.__doc__ == MidiBase.close_port.__doc__ */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6rtmidi_7_rtmidi_MidiBase), __pyx_n_s_close_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":879 * self._callback = None * * def close_port(self): # <<<<<<<<<<<<<< * self.cancel_callback() * MidiBase.close_port(self) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.close_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":885 * close_port.__doc__ == MidiBase.close_port.__doc__ * * def get_message(self): # <<<<<<<<<<<<<< * """Poll for MIDI input. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_13get_message(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_12get_message[] = "MidiIn.get_message(self)\nPoll for MIDI input.\n\n Checks whether a MIDI event is available in the input buffer and\n returns a two-element tuple with the MIDI message and a delta time. The\n MIDI message is a list of integers representing the data bytes of the\n message, the delta time is a float representing the time in seconds\n elapsed since the reception of the previous MIDI event.\n\n The function does not block. When no MIDI message is available, it\n returns ``None``.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_13get_message(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_message (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_12get_message(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_12get_message(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { std::vector __pyx_v_msg_v; double __pyx_v_delta_time; PyObject *__pyx_v_message = NULL; std::vector ::size_type __pyx_8genexpr3__pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; std::vector ::size_type __pyx_t_4; std::vector ::size_type __pyx_t_5; std::vector ::size_type __pyx_t_6; __Pyx_FakeReference __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_message", 0); /* "src/_rtmidi.pyx":899 * """ * cdef vector[unsigned char] msg_v * cdef double delta_time = self.thisptr.getMessage(&msg_v) # <<<<<<<<<<<<<< * * if not msg_v.empty(): */ __pyx_t_1 = __pyx_v_self->thisptr->getMessage((&__pyx_v_msg_v)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 899, __pyx_L1_error) __pyx_v_delta_time = __pyx_t_1; /* "src/_rtmidi.pyx":901 * cdef double delta_time = self.thisptr.getMessage(&msg_v) * * if not msg_v.empty(): # <<<<<<<<<<<<<< * message = [msg_v.at(i) for i in range(msg_v.size())] * return (message, delta_time) */ __pyx_t_2 = ((!(__pyx_v_msg_v.empty() != 0)) != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":902 * * if not msg_v.empty(): * message = [msg_v.at(i) for i in range(msg_v.size())] # <<<<<<<<<<<<<< * return (message, delta_time) * */ { /* enter inner scope */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_v_msg_v.size(); __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_8genexpr3__pyx_v_i = __pyx_t_6; try { __pyx_t_7 = __pyx_v_msg_v.at(__pyx_8genexpr3__pyx_v_i); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 902, __pyx_L1_error) } __pyx_t_8 = __Pyx_PyInt_From_unsigned_char(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 902, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } } /* exit inner scope */ __pyx_v_message = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "src/_rtmidi.pyx":903 * if not msg_v.empty(): * message = [msg_v.at(i) for i in range(msg_v.size())] * return (message, delta_time) # <<<<<<<<<<<<<< * * def ignore_types(self, sysex=True, timing=True, active_sense=True): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 903, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 903, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_message); __Pyx_GIVEREF(__pyx_v_message); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_message); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_8; __pyx_t_8 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":901 * cdef double delta_time = self.thisptr.getMessage(&msg_v) * * if not msg_v.empty(): # <<<<<<<<<<<<<< * message = [msg_v.at(i) for i in range(msg_v.size())] * return (message, delta_time) */ } /* "src/_rtmidi.pyx":885 * close_port.__doc__ == MidiBase.close_port.__doc__ * * def get_message(self): # <<<<<<<<<<<<<< * """Poll for MIDI input. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.get_message", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_message); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":905 * return (message, delta_time) * * def ignore_types(self, sysex=True, timing=True, active_sense=True): # <<<<<<<<<<<<<< * """Enable/Disable input filtering of certain types of MIDI events. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_15ignore_types(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_14ignore_types[] = "MidiIn.ignore_types(self, sysex=True, timing=True, active_sense=True)\nEnable/Disable input filtering of certain types of MIDI events.\n\n By default System Exclusive (aka sysex), MIDI Clock and Active Sensing\n messages are filtered from the MIDI input and never reach your code,\n because they can fill up input buffers very quickly.\n\n To receive them, you can selectively disable the filtering of these\n event types.\n\n To enable reception - i.e. turn off the default filtering - of sysex\n messages, pass ``sysex = False``.\n\n To enable reception of MIDI Clock, pass ``timing = False``.\n\n To enable reception of Active Sensing, pass ``active_sense = False``.\n\n These arguments can of course be combined in one call, and they all\n default to ``True``.\n\n If you enable reception of any of these event types, be sure to either\n use an input callback function, which returns quickly or poll for MIDI\n input often. Otherwise you might lose MIDI input because the input\n buffer overflows.\n\n **Windows note:** the Windows Multi Media API uses fixed size buffers\n for the reception of sysex messages, whose number and size is set at\n compile time. Sysex messages longer than the buffer size can not be\n received properly when using the Windows Multi Media API.\n\n The default distribution of python-rtmidi sets the number of sysex\n buffers to four and the size of each to 8192 bytes. To change these\n values, edit the ``RT_SYSEX_BUFFER_COUNT`` and ``RT_SYSEX_BUFFER_SIZE``\n preprocessor defines in ``RtMidi.cpp`` and recompile.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_15ignore_types(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_sysex = 0; PyObject *__pyx_v_timing = 0; PyObject *__pyx_v_active_sense = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ignore_types (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sysex,&__pyx_n_s_timing,&__pyx_n_s_active_sense,0}; PyObject* values[3] = {0,0,0}; values[0] = ((PyObject *)Py_True); values[1] = ((PyObject *)Py_True); values[2] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sysex); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timing); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_sense); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ignore_types") < 0)) __PYX_ERR(0, 905, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_sysex = values[0]; __pyx_v_timing = values[1]; __pyx_v_active_sense = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("ignore_types", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 905, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.ignore_types", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_14ignore_types(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_sysex, __pyx_v_timing, __pyx_v_active_sense); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_14ignore_types(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_sysex, PyObject *__pyx_v_timing, PyObject *__pyx_v_active_sense) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations bool __pyx_t_1; bool __pyx_t_2; bool __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ignore_types", 0); /* "src/_rtmidi.pyx":941 * * """ * self.thisptr.ignoreTypes(sysex, timing, active_sense) # <<<<<<<<<<<<<< * * def set_callback(self, func, data=None): */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_sysex); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_timing); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L1_error) __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_active_sense); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L1_error) __pyx_v_self->thisptr->ignoreTypes(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L1_error) /* "src/_rtmidi.pyx":905 * return (message, delta_time) * * def ignore_types(self, sysex=True, timing=True, active_sense=True): # <<<<<<<<<<<<<< * """Enable/Disable input filtering of certain types of MIDI events. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.ignore_types", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":943 * self.thisptr.ignoreTypes(sysex, timing, active_sense) * * def set_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for MIDI input. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_17set_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_16set_callback[] = "MidiIn.set_callback(self, func, data=None)\nRegister a callback function for MIDI input.\n\n The callback function is called whenever a MIDI message is received and\n must take two arguments. The first argument is a two-element tuple with\n the MIDI message and a delta time, like the one returned by the\n ``get_message`` method. The second argument is value of the ``data``\n argument passed to ``set_callback`` when the callback is registered.\n The value of ``data`` can be any Python object. It can be used inside\n the callback function to access data that would not be in scope\n otherwise.\n\n Registering a callback function replaces any previously registered\n callback.\n\n The callback function is safely removed when the input port is closed\n or the ``MidiIn`` instance is deleted.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_17set_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_func = 0; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_callback (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_func)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_callback") < 0)) __PYX_ERR(0, 943, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_func = values[0]; __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_callback", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 943, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.set_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_16set_callback(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_func, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_16set_callback(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_callback", 0); /* "src/_rtmidi.pyx":962 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.cancel_callback() * */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_callback); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 962, __pyx_L1_error) if (__pyx_t_1) { /* "src/_rtmidi.pyx":963 * """ * if self._callback: * self.cancel_callback() # <<<<<<<<<<<<<< * * self._callback = (func, data) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cancel_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/_rtmidi.pyx":962 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.cancel_callback() * */ } /* "src/_rtmidi.pyx":965 * self.cancel_callback() * * self._callback = (func, data) # <<<<<<<<<<<<<< * self.thisptr.setCallback(&_cb_func, self._callback) * */ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 965, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_func); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_data); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->_callback); __Pyx_DECREF(__pyx_v_self->_callback); __pyx_v_self->_callback = __pyx_t_2; __pyx_t_2 = 0; /* "src/_rtmidi.pyx":966 * * self._callback = (func, data) * self.thisptr.setCallback(&_cb_func, self._callback) # <<<<<<<<<<<<<< * * */ __pyx_v_self->thisptr->setCallback((&__pyx_f_6rtmidi_7_rtmidi__cb_func), ((void *)__pyx_v_self->_callback)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 966, __pyx_L1_error) /* "src/_rtmidi.pyx":943 * self.thisptr.ignoreTypes(sysex, timing, active_sense) * * def set_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for MIDI input. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.set_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_18__reduce_cython__[] = "MidiIn.__reduce_cython__(self)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_18__reduce_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_20__setstate_cython__[] = "MidiIn.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_6MidiIn_20__setstate_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_6MidiIn_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiIn.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1006 * cdef RtMidiOut *thisptr * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ static RtMidi *__pyx_f_6rtmidi_7_rtmidi_7MidiOut_baseptr(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { RtMidi *__pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("baseptr", 0); /* "src/_rtmidi.pyx":1007 * * cdef RtMidi* baseptr(self): * return self.thisptr # <<<<<<<<<<<<<< * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): */ __pyx_r = __pyx_v_self->thisptr; goto __pyx_L0; /* "src/_rtmidi.pyx":1006 * cdef RtMidiOut *thisptr * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1009 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): # <<<<<<<<<<<<<< * """Create a new client instance for MIDI output. * */ /* Python wrapper */ static int __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { enum RtMidi::Api __pyx_v_rtapi; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rtapi,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtapi); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 1009, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } if (values[0]) { __pyx_v_rtapi = ((enum RtMidi::Api)__Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(values[0])); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1009, __pyx_L3_error) } else { __pyx_v_rtapi = __pyx_k__7; } __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1009, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut___cinit__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self), __pyx_v_rtapi, __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6rtmidi_7_rtmidi_7MidiOut___cinit__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, enum RtMidi::Api __pyx_v_rtapi, PyObject *__pyx_v_name) { PyObject *__pyx_v_exc = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; std::string __pyx_t_9; RtMidiOut *__pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_name); /* "src/_rtmidi.pyx":1015 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiOut Client" * */ __pyx_t_1 = (__pyx_v_name == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":1016 * """ * if name is None: * name = "RtMidiOut Client" # <<<<<<<<<<<<<< * * try: */ __Pyx_INCREF(__pyx_kp_u_RtMidiOut_Client); __Pyx_DECREF_SET(__pyx_v_name, __pyx_kp_u_RtMidiOut_Client); /* "src/_rtmidi.pyx":1015 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiOut Client" * */ } /* "src/_rtmidi.pyx":1018 * name = "RtMidiOut Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "src/_rtmidi.pyx":1019 * * try: * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) # <<<<<<<<<<<<<< * except RuntimeError as exc: * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1019, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_name); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1019, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1019, __pyx_L4_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_t_10 = new RtMidiOut(__pyx_v_rtapi, __pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1019, __pyx_L4_error) } __pyx_v_self->thisptr = __pyx_t_10; /* "src/_rtmidi.pyx":1018 * name = "RtMidiOut Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/_rtmidi.pyx":1020 * try: * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: # <<<<<<<<<<<<<< * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * */ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_11) { __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 1020, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_v_exc = __pyx_t_7; /*try:*/ { /* "src/_rtmidi.pyx":1021 * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) # <<<<<<<<<<<<<< * * self.set_error_callback(_default_error_handler) */ __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_exc); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_15 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_15); if (PyDict_SetItem(__pyx_t_13, __pyx_n_s_type, __pyx_t_15) < 0) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1021, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_Raise(__pyx_t_15, 0, 0, 0); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __PYX_ERR(0, 1021, __pyx_L15_error) } /* "src/_rtmidi.pyx":1020 * try: * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: # <<<<<<<<<<<<<< * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * */ /*finally:*/ { __pyx_L15_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_11 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L6_except_error; } } } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/_rtmidi.pyx":1018 * name = "RtMidiOut Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L9_try_end:; } /* "src/_rtmidi.pyx":1023 * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * * self.set_error_callback(_default_error_handler) # <<<<<<<<<<<<<< * self._port = None * self._deleted = False */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_error_callback); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_default_error_handler); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_15)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_8 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_15, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/_rtmidi.pyx":1024 * * self.set_error_callback(_default_error_handler) * self._port = None # <<<<<<<<<<<<<< * self._deleted = False * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->__pyx_base._port); __Pyx_DECREF(__pyx_v_self->__pyx_base._port); __pyx_v_self->__pyx_base._port = Py_None; /* "src/_rtmidi.pyx":1025 * self.set_error_callback(_default_error_handler) * self._port = None * self._deleted = False # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->__pyx_base._deleted); __Pyx_DECREF(__pyx_v_self->__pyx_base._deleted); __pyx_v_self->__pyx_base._deleted = Py_False; /* "src/_rtmidi.pyx":1009 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): # <<<<<<<<<<<<<< * """Create a new client instance for MIDI output. * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_exc); __Pyx_XDECREF(__pyx_v_name); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1027 * self._deleted = False * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* Python wrapper */ static void __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_3__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_2__dealloc__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_2__dealloc__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "src/_rtmidi.pyx":1029 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ __pyx_t_1 = __Pyx_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_u_thisptr); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 1029, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":1030 * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): * del self.thisptr # <<<<<<<<<<<<<< * * def delete(self): */ delete __pyx_v_self->thisptr; /* "src/_rtmidi.pyx":1029 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ } /* "src/_rtmidi.pyx":1027 * self._deleted = False * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("rtmidi._rtmidi.MidiOut.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "src/_rtmidi.pyx":1032 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_5delete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_4delete[] = "MidiOut.delete(self)\nDe-allocate pointer to C++ class instance.\n\n .. warning:: the instance **must not** be used anymore after calling\n this method, otherwise the program will crash with a segmentation\n fault!\n\n The reason this potentially dangerous method exists is that in\n some cases it is desirable to destroy the internal ``RtMidiOut``\n C++ class instance with immediate effect, thereby closing the\n backend MIDI API client and all the ports it opened. By merely\n using ``del`` on the ``rtmidi.MidiOut`` Python instance, the\n destruction of the C++ instance may be delayed for an arbitrary\n amount of time, until the Python garbage collector cleans up the\n instance.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_5delete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_4delete(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_4delete(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("delete", 0); /* "src/_rtmidi.pyx":1049 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->__pyx_base._deleted); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1049, __pyx_L1_error) __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "src/_rtmidi.pyx":1050 * """ * if not self._deleted: * del self.thisptr # <<<<<<<<<<<<<< * self._deleted = True * */ delete __pyx_v_self->thisptr; /* "src/_rtmidi.pyx":1051 * if not self._deleted: * del self.thisptr * self._deleted = True # <<<<<<<<<<<<<< * * @property */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_v_self->__pyx_base._deleted); __Pyx_DECREF(__pyx_v_self->__pyx_base._deleted); __pyx_v_self->__pyx_base._deleted = Py_True; /* "src/_rtmidi.pyx":1049 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ } /* "src/_rtmidi.pyx":1032 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1054 * * @property * def is_deleted(self): # <<<<<<<<<<<<<< * return self._deleted * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_10is_deleted_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_10is_deleted_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10is_deleted___get__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10is_deleted___get__(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "src/_rtmidi.pyx":1055 * @property * def is_deleted(self): * return self._deleted # <<<<<<<<<<<<<< * * def get_current_api(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->__pyx_base._deleted); __pyx_r = __pyx_v_self->__pyx_base._deleted; goto __pyx_L0; /* "src/_rtmidi.pyx":1054 * * @property * def is_deleted(self): # <<<<<<<<<<<<<< * return self._deleted * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1057 * return self._deleted * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_7get_current_api(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_6get_current_api[] = "MidiOut.get_current_api(self)\nReturn the low-level MIDI backend API used by this instance.\n\n Use this by comparing the returned value to the module-level ``API_*``\n constants, e.g.::\n\n midiout = rtmidi.MidiOut()\n\n if midiout.get_current_api() == rtmidi.API_UNIX_JACK:\n print(\"Using JACK API for MIDI output.\")\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_7get_current_api(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_current_api (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_6get_current_api(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_6get_current_api(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_current_api", 0); /* "src/_rtmidi.pyx":1069 * * """ * return self.thisptr.getCurrentApi() # <<<<<<<<<<<<<< * * def send_message(self, message): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(__pyx_v_self->thisptr->getCurrentApi()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1069, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/_rtmidi.pyx":1057 * return self._deleted * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.get_current_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/_rtmidi.pyx":1071 * return self.thisptr.getCurrentApi() * * def send_message(self, message): # <<<<<<<<<<<<<< * """Send a MIDI message to the output port. * */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_9send_message(PyObject *__pyx_v_self, PyObject *__pyx_v_message); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_8send_message[] = "MidiOut.send_message(self, message)\nSend a MIDI message to the output port.\n\n The message must be passed as an iterable yielding integers, each\n element representing one byte of the MIDI message.\n\n Normal MIDI messages have a length of one to three bytes, but you can\n also send system exclusive messages, which can be arbitrarily long, via\n this method.\n\n No check is made whether the passed data constitutes a valid MIDI\n message but if it is longer than 3 bytes, the value of the first byte\n must be a start-of-sysex status byte, i.e. 0xF0.\n\n Exceptions:\n\n ``ValueError``\n Raised if ``message`` argument is empty or more than 3 bytes long\n and not a SysEx message.\n\n "; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_9send_message(PyObject *__pyx_v_self, PyObject *__pyx_v_message) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("send_message (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_8send_message(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self), ((PyObject *)__pyx_v_message)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_8send_message(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, PyObject *__pyx_v_message) { std::vector __pyx_v_msg_v; PyObject *__pyx_v_c = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *(*__pyx_t_6)(PyObject *); unsigned char __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("send_message", 0); /* "src/_rtmidi.pyx":1094 * cdef vector[unsigned char] msg_v * * if not message: # <<<<<<<<<<<<<< * raise ValueError("'message' must not be empty.") * */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_message); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1094, __pyx_L1_error) __pyx_t_2 = ((!__pyx_t_1) != 0); if (unlikely(__pyx_t_2)) { /* "src/_rtmidi.pyx":1095 * * if not message: * raise ValueError("'message' must not be empty.") # <<<<<<<<<<<<<< * * if len(message) > 3 and message[0] != 0xF0: */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1095, __pyx_L1_error) /* "src/_rtmidi.pyx":1094 * cdef vector[unsigned char] msg_v * * if not message: # <<<<<<<<<<<<<< * raise ValueError("'message' must not be empty.") * */ } /* "src/_rtmidi.pyx":1097 * raise ValueError("'message' must not be empty.") * * if len(message) > 3 and message[0] != 0xF0: # <<<<<<<<<<<<<< * raise ValueError("'message' longer than 3 bytes but does not " * "start with 0xF0.") */ __pyx_t_4 = PyObject_Length(__pyx_v_message); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1097, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_4 > 3) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L5_bool_binop_done; } __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_message, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_240, 0xF0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L5_bool_binop_done:; if (unlikely(__pyx_t_2)) { /* "src/_rtmidi.pyx":1098 * * if len(message) > 3 and message[0] != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " # <<<<<<<<<<<<<< * "start with 0xF0.") * */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1098, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1098, __pyx_L1_error) /* "src/_rtmidi.pyx":1097 * raise ValueError("'message' must not be empty.") * * if len(message) > 3 and message[0] != 0xF0: # <<<<<<<<<<<<<< * raise ValueError("'message' longer than 3 bytes but does not " * "start with 0xF0.") */ } /* "src/_rtmidi.pyx":1101 * "start with 0xF0.") * * for c in message: # <<<<<<<<<<<<<< * msg_v.push_back(c) * */ if (likely(PyList_CheckExact(__pyx_v_message)) || PyTuple_CheckExact(__pyx_v_message)) { __pyx_t_5 = __pyx_v_message; __Pyx_INCREF(__pyx_t_5); __pyx_t_4 = 0; __pyx_t_6 = NULL; } else { __pyx_t_4 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_message); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1101, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_5))) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_5)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 1101, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_5)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 1101, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1101, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_3); __pyx_t_3 = 0; /* "src/_rtmidi.pyx":1102 * * for c in message: * msg_v.push_back(c) # <<<<<<<<<<<<<< * * self.thisptr.sendMessage(&msg_v) */ __pyx_t_7 = __Pyx_PyInt_As_unsigned_char(__pyx_v_c); if (unlikely((__pyx_t_7 == (unsigned char)-1) && PyErr_Occurred())) __PYX_ERR(0, 1102, __pyx_L1_error) try { __pyx_v_msg_v.push_back(__pyx_t_7); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1102, __pyx_L1_error) } /* "src/_rtmidi.pyx":1101 * "start with 0xF0.") * * for c in message: # <<<<<<<<<<<<<< * msg_v.push_back(c) * */ } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/_rtmidi.pyx":1104 * msg_v.push_back(c) * * self.thisptr.sendMessage(&msg_v) # <<<<<<<<<<<<<< */ __pyx_v_self->thisptr->sendMessage((&__pyx_v_msg_v)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1104, __pyx_L1_error) /* "src/_rtmidi.pyx":1071 * return self.thisptr.getCurrentApi() * * def send_message(self, message): # <<<<<<<<<<<<<< * """Send a MIDI message to the output port. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.send_message", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_c); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_10__reduce_cython__[] = "MidiOut.__reduce_cython__(self)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10__reduce_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_12__setstate_cython__[] = "MidiOut.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_7MidiOut_12__setstate_cython__(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_7MidiOut_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("rtmidi._rtmidi.MidiOut.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_6rtmidi_7_rtmidi_15__pyx_unpickle_MidiBase(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6rtmidi_7_rtmidi_14__pyx_unpickle_MidiBase[] = "__pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state)"; static PyMethodDef __pyx_mdef_6rtmidi_7_rtmidi_15__pyx_unpickle_MidiBase = {"__pyx_unpickle_MidiBase", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_15__pyx_unpickle_MidiBase, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_14__pyx_unpickle_MidiBase}; static PyObject *__pyx_pw_6rtmidi_7_rtmidi_15__pyx_unpickle_MidiBase(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_MidiBase (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_MidiBase", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_MidiBase", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_MidiBase") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_MidiBase", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("rtmidi._rtmidi.__pyx_unpickle_MidiBase", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6rtmidi_7_rtmidi_14__pyx_unpickle_MidiBase(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6rtmidi_7_rtmidi_14__pyx_unpickle_MidiBase(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_MidiBase", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0x9171c0f: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) */ __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x9171c0f) != 0); if (__pyx_t_1) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum != 0x9171c0f: * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) * __pyx_result = MidiBase.__new__(__pyx_type) */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_2); __pyx_v___pyx_PickleError = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum != 0x9171c0f: * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = MidiBase.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x91, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0x9171c0f: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) * __pyx_result = MidiBase.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6rtmidi_7_rtmidi_MidiBase), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v___pyx_result = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) * __pyx_result = MidiBase.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_1 = (__pyx_v___pyx_state != Py_None); __pyx_t_6 = (__pyx_t_1 != 0); if (__pyx_t_6) { /* "(tree fragment)":9 * __pyx_result = MidiBase.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_3 = __pyx_f_6rtmidi_7_rtmidi___pyx_unpickle_MidiBase__set_state(((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x9171c0f = (_deleted, _error_callback, _port))" % __pyx_checksum) * __pyx_result = MidiBase.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("rtmidi._rtmidi.__pyx_unpickle_MidiBase", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_6rtmidi_7_rtmidi___pyx_unpickle_MidiBase__set_state(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_MidiBase__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] # <<<<<<<<<<<<<< * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[3]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->_deleted); __Pyx_DECREF(__pyx_v___pyx_result->_deleted); __pyx_v___pyx_result->_deleted = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->_error_callback); __Pyx_DECREF(__pyx_v___pyx_result->_error_callback); __pyx_v___pyx_result->_error_callback = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->_port); __Pyx_DECREF(__pyx_v___pyx_result->_port); __pyx_v___pyx_result->_port = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[3]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_3 > 3) != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[3]) */ } /* "(tree fragment)":11 * __pyx_unpickle_MidiBase__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_MidiBase__set_state(MidiBase __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result._deleted = __pyx_state[0]; __pyx_result._error_callback = __pyx_state[1]; __pyx_result._port = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("rtmidi._rtmidi.__pyx_unpickle_MidiBase__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.to_py":31 * * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_PyObject_string_to_py_std__in_string", 0); /* "string.to_py":32 * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< * cdef extern from *: * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "string.to_py":31 * * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.to_py":37 * * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_PyUnicode_string_to_py_std__in_string", 0); /* "string.to_py":38 * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< * cdef extern from *: * cdef object __Pyx_PyStr_FromStringAndSize(const char*, size_t) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "string.to_py":37 * * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.to_py":43 * * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_PyStr_string_to_py_std__in_string", 0); /* "string.to_py":44 * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< * cdef extern from *: * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "string.to_py":43 * * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.to_py":49 * * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_PyBytes_string_to_py_std__in_string", 0); /* "string.to_py":50 * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< * cdef extern from *: * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "string.to_py":49 * * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) * cdef extern from *: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.to_py":55 * * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) * */ static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_PyByteArray_string_to_py_std__in_string", 0); /* "string.to_py":56 * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "string.to_py":55 * * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "string.from_py":13 * * @cname("__pyx_convert_string_from_py_std__in_string") * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< * cdef Py_ssize_t length = 0 * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { Py_ssize_t __pyx_v_length; char const *__pyx_v_data; std::string __pyx_r; __Pyx_RefNannyDeclarations char const *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); /* "string.from_py":14 * @cname("__pyx_convert_string_from_py_std__in_string") * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) * return string(data, length) */ __pyx_v_length = 0; /* "string.from_py":15 * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: * cdef Py_ssize_t length = 0 * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< * return string(data, length) * */ __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) __pyx_v_data = __pyx_t_1; /* "string.from_py":16 * cdef Py_ssize_t length = 0 * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) * return string(data, length) # <<<<<<<<<<<<<< * * */ __pyx_r = std::string(__pyx_v_data, __pyx_v_length); goto __pyx_L0; /* "string.from_py":13 * * @cname("__pyx_convert_string_from_py_std__in_string") * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< * cdef Py_ssize_t length = 0 * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase __pyx_vtable_6rtmidi_7_rtmidi_MidiBase; static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiBase(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)o); p->__pyx_vtab = __pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase; p->_port = Py_None; Py_INCREF(Py_None); p->_error_callback = Py_None; Py_INCREF(Py_None); p->_deleted = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiBase(PyObject *o) { struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->_port); Py_CLEAR(p->_error_callback); Py_CLEAR(p->_deleted); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiBase(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)o; if (p->_port) { e = (*v)(p->_port, a); if (e) return e; } if (p->_error_callback) { e = (*v)(p->_error_callback, a); if (e) return e; } if (p->_deleted) { e = (*v)(p->_deleted, a); if (e) return e; } return 0; } static int __pyx_tp_clear_6rtmidi_7_rtmidi_MidiBase(PyObject *o) { PyObject* tmp; struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *)o; tmp = ((PyObject*)p->_port); p->_port = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_error_callback); p->_error_callback = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_deleted); p->_deleted = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_6rtmidi_7_rtmidi_MidiBase[] = { {"__enter__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_1__enter__, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase___enter__}, {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_3__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_2__exit__}, {"_check_port", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_5_check_port, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_4_check_port}, {"_decode_string", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_7_decode_string, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_6_decode_string}, {"get_port_count", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_9get_port_count, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_8get_port_count}, {"get_port_name", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_11get_port_name, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_10get_port_name}, {"get_ports", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_13get_ports, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_12get_ports}, {"is_port_open", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_15is_port_open, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_14is_port_open}, {"open_port", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_17open_port, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_16open_port}, {"open_virtual_port", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_19open_virtual_port, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_18open_virtual_port}, {"close_port", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_21close_port, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_20close_port}, {"set_client_name", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_23set_client_name, METH_O, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_22set_client_name}, {"set_port_name", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_25set_port_name, METH_O, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_24set_port_name}, {"set_error_callback", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_27set_error_callback, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_26set_error_callback}, {"cancel_error_callback", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_29cancel_error_callback, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_28cancel_error_callback}, {"__reduce_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_31__reduce_cython__, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_30__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_8MidiBase_33__setstate_cython__, METH_O, __pyx_doc_6rtmidi_7_rtmidi_8MidiBase_32__setstate_cython__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6rtmidi_7_rtmidi_MidiBase = { PyVarObject_HEAD_INIT(0, 0) "rtmidi._rtmidi.MidiBase", /*tp_name*/ sizeof(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiBase, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiBase, /*tp_traverse*/ __pyx_tp_clear_6rtmidi_7_rtmidi_MidiBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6rtmidi_7_rtmidi_MidiBase, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6rtmidi_7_rtmidi_MidiBase, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiIn __pyx_vtable_6rtmidi_7_rtmidi_MidiIn; static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiIn(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *p; PyObject *o = __pyx_tp_new_6rtmidi_7_rtmidi_MidiBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase*)__pyx_vtabptr_6rtmidi_7_rtmidi_MidiIn; p->_callback = Py_None; Py_INCREF(Py_None); if (unlikely(__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiIn(PyObject *o) { struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_5__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->_callback); PyObject_GC_Track(o); __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiBase(o); } static int __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiIn(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)o; e = __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiBase(o, v, a); if (e) return e; if (p->_callback) { e = (*v)(p->_callback, a); if (e) return e; } return 0; } static int __pyx_tp_clear_6rtmidi_7_rtmidi_MidiIn(PyObject *o) { PyObject* tmp; struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *p = (struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn *)o; __pyx_tp_clear_6rtmidi_7_rtmidi_MidiBase(o); tmp = ((PyObject*)p->_callback); p->_callback = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_6rtmidi_7_rtmidi_6MidiIn_is_deleted(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_6rtmidi_7_rtmidi_6MidiIn_10is_deleted_1__get__(o); } static PyMethodDef __pyx_methods_6rtmidi_7_rtmidi_MidiIn[] = { {"get_current_api", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_3get_current_api, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_2get_current_api}, {"delete", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_7delete, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_6delete}, {"cancel_callback", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_9cancel_callback, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_8cancel_callback}, {"close_port", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_11close_port, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_10close_port}, {"get_message", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_13get_message, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_12get_message}, {"ignore_types", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_15ignore_types, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_14ignore_types}, {"set_callback", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_17set_callback, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_16set_callback}, {"__reduce_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_19__reduce_cython__, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_18__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_6MidiIn_21__setstate_cython__, METH_O, __pyx_doc_6rtmidi_7_rtmidi_6MidiIn_20__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_6rtmidi_7_rtmidi_MidiIn[] = { {(char *)"is_deleted", __pyx_getprop_6rtmidi_7_rtmidi_6MidiIn_is_deleted, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_6rtmidi_7_rtmidi_MidiIn = { PyVarObject_HEAD_INIT(0, 0) "rtmidi._rtmidi.MidiIn", /*tp_name*/ sizeof(struct __pyx_obj_6rtmidi_7_rtmidi_MidiIn), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiIn, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "Midi input client interface.\n\n ``rtmidi.MidiIn(rtapi=API_UNSPECIFIED, name=\"RtMidi Client\", queue_size_limit=1024)``\n\n You can specify the low-level MIDI backend API to use via the ``rtapi``\n keyword or the first positional argument, passing one of the module-level\n ``API_*`` constants. You can get a list of compiled-in APIs with the\n module-level ``get_compiled_api`` function. If you pass ``API_UNSPECIFIED``\n (the default), the first compiled-in API, which has any input ports\n available, will be used.\n\n You can optionally pass a name for the MIDI client with the ``name``\n keyword or the second positional argument. Names with non-ASCII characters\n in them have to be passed as unicode or UTF-8 encoded strings in Python 2.\n The default name is ``\"RtMidiIn Client\"``.\n\n .. note::\n With some backend APIs (e.g. ALSA), the client name is set by the first\n ``MidiIn`` *or* ``MidiOut`` created by your program and does not change\n unless you either use the ``set_client_name`` method, or until *all*\n ``MidiIn`` and ``MidiOut`` instances are deleted and then a new one is\n created.\n\n The ``queue_size_limit`` argument specifies the size of the internal ring\n buffer in which incoming MIDI events are placed until retrieved via the\n ``get_message`` method (i.e. when no callback function is registered).\n The default value is ``1024`` (overriding the default value ``100`` of the\n underlying C++ RtMidi library).\n\n Exceptions:\n\n ``SystemError``\n Raised when the RtMidi backend initialization fails. The execption\n message should have more information on the cause of the error.\n\n ``TypeError``\n Raised when an incompatible value type is passed for a parameter.\n\n ", /*tp_doc*/ __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiIn, /*tp_traverse*/ __pyx_tp_clear_6rtmidi_7_rtmidi_MidiIn, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6rtmidi_7_rtmidi_MidiIn, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_6rtmidi_7_rtmidi_MidiIn, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6rtmidi_7_rtmidi_MidiIn, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiOut __pyx_vtable_6rtmidi_7_rtmidi_MidiOut; static PyObject *__pyx_tp_new_6rtmidi_7_rtmidi_MidiOut(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *p; PyObject *o = __pyx_tp_new_6rtmidi_7_rtmidi_MidiBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6rtmidi_7_rtmidi_MidiBase*)__pyx_vtabptr_6rtmidi_7_rtmidi_MidiOut; if (unlikely(__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiOut(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } PyObject_GC_Track(o); __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiBase(o); } static PyObject *__pyx_getprop_6rtmidi_7_rtmidi_7MidiOut_is_deleted(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_6rtmidi_7_rtmidi_7MidiOut_10is_deleted_1__get__(o); } static PyMethodDef __pyx_methods_6rtmidi_7_rtmidi_MidiOut[] = { {"delete", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_5delete, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_4delete}, {"get_current_api", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_7get_current_api, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_6get_current_api}, {"send_message", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_9send_message, METH_O, __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_8send_message}, {"__reduce_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_11__reduce_cython__, METH_NOARGS, __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_10__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_6rtmidi_7_rtmidi_7MidiOut_13__setstate_cython__, METH_O, __pyx_doc_6rtmidi_7_rtmidi_7MidiOut_12__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_6rtmidi_7_rtmidi_MidiOut[] = { {(char *)"is_deleted", __pyx_getprop_6rtmidi_7_rtmidi_7MidiOut_is_deleted, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_6rtmidi_7_rtmidi_MidiOut = { PyVarObject_HEAD_INIT(0, 0) "rtmidi._rtmidi.MidiOut", /*tp_name*/ sizeof(struct __pyx_obj_6rtmidi_7_rtmidi_MidiOut), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6rtmidi_7_rtmidi_MidiOut, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "Midi output client interface.\n\n ``rtmidi.MidiOut(rtapi=API_UNSPECIFIED, name=\"RtMidi Client\")``\n\n You can specify the low-level MIDI backend API to use via the ``rtapi``\n keyword or the first positional argument, passing one of the module-level\n ``API_*`` constants. You can get a list of compiled-in APIs with the\n module-level ``get_compiled_api`` function. If you pass ``API_UNSPECIFIED``\n (the default), the first compiled-in API, which has any input ports\n available, will be used.\n\n You can optionally pass a name for the MIDI client with the ``name``\n keyword or the second positional argument. Names with non-ASCII characters\n in them have to be passed as unicode or UTF-8 encoded strings in Python 2.\n The default name is ``\"RtMidiOut Client\"``.\n\n .. note::\n With some backend APIs (e.g. ALSA), the client name is set by the first\n ``MidiIn`` *or* ``MidiOut`` created by your program and does not change\n unless you either use the ``set_client_name`` method, or until *all*\n ``MidiIn`` and ``MidiOut`` instances are deleted and then a new one is\n created.\n\n Exceptions:\n\n ``SystemError``\n Raised when the RtMidi backend initialization fails. The execption\n message should have more information on the cause of the error.\n\n ``TypeError``\n Raised when an incompatible value type is passed for a parameter.\n\n ", /*tp_doc*/ __pyx_tp_traverse_6rtmidi_7_rtmidi_MidiBase, /*tp_traverse*/ __pyx_tp_clear_6rtmidi_7_rtmidi_MidiBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6rtmidi_7_rtmidi_MidiOut, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_6rtmidi_7_rtmidi_MidiOut, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6rtmidi_7_rtmidi_MidiOut, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__rtmidi(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__rtmidi}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_rtmidi", __pyx_k_A_Python_binding_for_the_RtMidi, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_API_LINUX_ALSA, __pyx_k_API_LINUX_ALSA, sizeof(__pyx_k_API_LINUX_ALSA), 0, 0, 1, 1}, {&__pyx_n_u_API_LINUX_ALSA, __pyx_k_API_LINUX_ALSA, sizeof(__pyx_k_API_LINUX_ALSA), 0, 1, 0, 1}, {&__pyx_n_s_API_MACOSX_CORE, __pyx_k_API_MACOSX_CORE, sizeof(__pyx_k_API_MACOSX_CORE), 0, 0, 1, 1}, {&__pyx_n_u_API_MACOSX_CORE, __pyx_k_API_MACOSX_CORE, sizeof(__pyx_k_API_MACOSX_CORE), 0, 1, 0, 1}, {&__pyx_n_s_API_RTMIDI_DUMMY, __pyx_k_API_RTMIDI_DUMMY, sizeof(__pyx_k_API_RTMIDI_DUMMY), 0, 0, 1, 1}, {&__pyx_n_u_API_RTMIDI_DUMMY, __pyx_k_API_RTMIDI_DUMMY, sizeof(__pyx_k_API_RTMIDI_DUMMY), 0, 1, 0, 1}, {&__pyx_n_s_API_UNIX_JACK, __pyx_k_API_UNIX_JACK, sizeof(__pyx_k_API_UNIX_JACK), 0, 0, 1, 1}, {&__pyx_n_u_API_UNIX_JACK, __pyx_k_API_UNIX_JACK, sizeof(__pyx_k_API_UNIX_JACK), 0, 1, 0, 1}, {&__pyx_n_s_API_UNSPECIFIED, __pyx_k_API_UNSPECIFIED, sizeof(__pyx_k_API_UNSPECIFIED), 0, 0, 1, 1}, {&__pyx_n_u_API_UNSPECIFIED, __pyx_k_API_UNSPECIFIED, sizeof(__pyx_k_API_UNSPECIFIED), 0, 1, 0, 1}, {&__pyx_n_s_API_WINDOWS_MM, __pyx_k_API_WINDOWS_MM, sizeof(__pyx_k_API_WINDOWS_MM), 0, 0, 1, 1}, {&__pyx_n_u_API_WINDOWS_MM, __pyx_k_API_WINDOWS_MM, sizeof(__pyx_k_API_WINDOWS_MM), 0, 1, 0, 1}, {&__pyx_kp_u_API_backend_does_not_support_cha, __pyx_k_API_backend_does_not_support_cha, sizeof(__pyx_k_API_backend_does_not_support_cha), 0, 1, 0, 0}, {&__pyx_kp_u_API_backend_does_not_support_cha_2, __pyx_k_API_backend_does_not_support_cha_2, sizeof(__pyx_k_API_backend_does_not_support_cha_2), 0, 1, 0, 0}, {&__pyx_kp_s_Base_general_RtMidi_exception_Al, __pyx_k_Base_general_RtMidi_exception_Al, sizeof(__pyx_k_Base_general_RtMidi_exception_Al), 0, 0, 1, 0}, {&__pyx_n_s_ERRORTYPE_DEBUG_WARNING, __pyx_k_ERRORTYPE_DEBUG_WARNING, sizeof(__pyx_k_ERRORTYPE_DEBUG_WARNING), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_DEBUG_WARNING, __pyx_k_ERRORTYPE_DEBUG_WARNING, sizeof(__pyx_k_ERRORTYPE_DEBUG_WARNING), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_DRIVER_ERROR, __pyx_k_ERRORTYPE_DRIVER_ERROR, sizeof(__pyx_k_ERRORTYPE_DRIVER_ERROR), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_DRIVER_ERROR, __pyx_k_ERRORTYPE_DRIVER_ERROR, sizeof(__pyx_k_ERRORTYPE_DRIVER_ERROR), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_INVALID_DEVICE, __pyx_k_ERRORTYPE_INVALID_DEVICE, sizeof(__pyx_k_ERRORTYPE_INVALID_DEVICE), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_INVALID_DEVICE, __pyx_k_ERRORTYPE_INVALID_DEVICE, sizeof(__pyx_k_ERRORTYPE_INVALID_DEVICE), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_INVALID_PARAMETER, __pyx_k_ERRORTYPE_INVALID_PARAMETER, sizeof(__pyx_k_ERRORTYPE_INVALID_PARAMETER), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_INVALID_PARAMETER, __pyx_k_ERRORTYPE_INVALID_PARAMETER, sizeof(__pyx_k_ERRORTYPE_INVALID_PARAMETER), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_INVALID_USE, __pyx_k_ERRORTYPE_INVALID_USE, sizeof(__pyx_k_ERRORTYPE_INVALID_USE), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_INVALID_USE, __pyx_k_ERRORTYPE_INVALID_USE, sizeof(__pyx_k_ERRORTYPE_INVALID_USE), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_MEMORY_ERROR, __pyx_k_ERRORTYPE_MEMORY_ERROR, sizeof(__pyx_k_ERRORTYPE_MEMORY_ERROR), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_MEMORY_ERROR, __pyx_k_ERRORTYPE_MEMORY_ERROR, sizeof(__pyx_k_ERRORTYPE_MEMORY_ERROR), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND, __pyx_k_ERRORTYPE_NO_DEVICES_FOUND, sizeof(__pyx_k_ERRORTYPE_NO_DEVICES_FOUND), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND, __pyx_k_ERRORTYPE_NO_DEVICES_FOUND, sizeof(__pyx_k_ERRORTYPE_NO_DEVICES_FOUND), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_SYSTEM_ERROR, __pyx_k_ERRORTYPE_SYSTEM_ERROR, sizeof(__pyx_k_ERRORTYPE_SYSTEM_ERROR), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_SYSTEM_ERROR, __pyx_k_ERRORTYPE_SYSTEM_ERROR, sizeof(__pyx_k_ERRORTYPE_SYSTEM_ERROR), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_THREAD_ERROR, __pyx_k_ERRORTYPE_THREAD_ERROR, sizeof(__pyx_k_ERRORTYPE_THREAD_ERROR), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_THREAD_ERROR, __pyx_k_ERRORTYPE_THREAD_ERROR, sizeof(__pyx_k_ERRORTYPE_THREAD_ERROR), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_UNSPECIFIED, __pyx_k_ERRORTYPE_UNSPECIFIED, sizeof(__pyx_k_ERRORTYPE_UNSPECIFIED), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_UNSPECIFIED, __pyx_k_ERRORTYPE_UNSPECIFIED, sizeof(__pyx_k_ERRORTYPE_UNSPECIFIED), 0, 1, 0, 1}, {&__pyx_n_s_ERRORTYPE_WARNING, __pyx_k_ERRORTYPE_WARNING, sizeof(__pyx_k_ERRORTYPE_WARNING), 0, 0, 1, 1}, {&__pyx_n_u_ERRORTYPE_WARNING, __pyx_k_ERRORTYPE_WARNING, sizeof(__pyx_k_ERRORTYPE_WARNING), 0, 1, 0, 1}, {&__pyx_kp_s_Incompatible_checksums_s_vs_0x91, __pyx_k_Incompatible_checksums_s_vs_0x91, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x91), 0, 0, 1, 0}, {&__pyx_n_s_InvalidPortError, __pyx_k_InvalidPortError, sizeof(__pyx_k_InvalidPortError), 0, 0, 1, 1}, {&__pyx_n_u_InvalidPortError, __pyx_k_InvalidPortError, sizeof(__pyx_k_InvalidPortError), 0, 1, 0, 1}, {&__pyx_n_s_InvalidUseError, __pyx_k_InvalidUseError, sizeof(__pyx_k_InvalidUseError), 0, 0, 1, 1}, {&__pyx_n_u_InvalidUseError, __pyx_k_InvalidUseError, sizeof(__pyx_k_InvalidUseError), 0, 1, 0, 1}, {&__pyx_kp_u_JACK_server_not_running, __pyx_k_JACK_server_not_running, sizeof(__pyx_k_JACK_server_not_running), 0, 1, 0, 0}, {&__pyx_n_s_MemoryAllocationError, __pyx_k_MemoryAllocationError, sizeof(__pyx_k_MemoryAllocationError), 0, 0, 1, 1}, {&__pyx_n_u_MemoryAllocationError, __pyx_k_MemoryAllocationError, sizeof(__pyx_k_MemoryAllocationError), 0, 1, 0, 1}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase, __pyx_k_MidiBase, sizeof(__pyx_k_MidiBase), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn, __pyx_k_MidiIn, sizeof(__pyx_k_MidiIn), 0, 0, 1, 1}, {&__pyx_n_u_MidiIn, __pyx_k_MidiIn, sizeof(__pyx_k_MidiIn), 0, 1, 0, 1}, {&__pyx_n_s_MidiOut, __pyx_k_MidiOut, sizeof(__pyx_k_MidiOut), 0, 0, 1, 1}, {&__pyx_n_u_MidiOut, __pyx_k_MidiOut, sizeof(__pyx_k_MidiOut), 0, 1, 0, 1}, {&__pyx_n_s_NoDevicesError, __pyx_k_NoDevicesError, sizeof(__pyx_k_NoDevicesError), 0, 0, 1, 1}, {&__pyx_n_u_NoDevicesError, __pyx_k_NoDevicesError, sizeof(__pyx_k_NoDevicesError), 0, 1, 0, 1}, {&__pyx_kp_u_No_port_currently_opened, __pyx_k_No_port_currently_opened, sizeof(__pyx_k_No_port_currently_opened), 0, 1, 0, 0}, {&__pyx_kp_u_None, __pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0, 0}, {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_kp_s_Raised_if_a_memory_allocation_fa, __pyx_k_Raised_if_a_memory_allocation_fa, sizeof(__pyx_k_Raised_if_a_memory_allocation_fa), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_if_a_method_is_not_suppor, __pyx_k_Raised_if_a_method_is_not_suppor, sizeof(__pyx_k_Raised_if_a_method_is_not_suppor), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_if_an_error_happened_at_t, __pyx_k_Raised_if_an_error_happened_at_t, sizeof(__pyx_k_Raised_if_an_error_happened_at_t), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo, __pyx_k_Raised_if_no_MIDI_devices_are_fo, sizeof(__pyx_k_Raised_if_no_MIDI_devices_are_fo), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_when_an_invalid_port_numb, __pyx_k_Raised_when_an_invalid_port_numb, sizeof(__pyx_k_Raised_when_an_invalid_port_numb), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_when_an_method_call_is_no, __pyx_k_Raised_when_an_method_call_is_no, sizeof(__pyx_k_Raised_when_an_method_call_is_no), 0, 0, 1, 0}, {&__pyx_n_s_RtMidiError, __pyx_k_RtMidiError, sizeof(__pyx_k_RtMidiError), 0, 0, 1, 1}, {&__pyx_n_u_RtMidiError, __pyx_k_RtMidiError, sizeof(__pyx_k_RtMidiError), 0, 1, 0, 1}, {&__pyx_n_s_RtMidiError___init, __pyx_k_RtMidiError___init, sizeof(__pyx_k_RtMidiError___init), 0, 0, 1, 1}, {&__pyx_kp_u_RtMidiIn_Client, __pyx_k_RtMidiIn_Client, sizeof(__pyx_k_RtMidiIn_Client), 0, 1, 0, 0}, {&__pyx_kp_u_RtMidiOut_Client, __pyx_k_RtMidiOut_Client, sizeof(__pyx_k_RtMidiOut_Client), 0, 1, 0, 0}, {&__pyx_kp_u_RtMidi_s, __pyx_k_RtMidi_s, sizeof(__pyx_k_RtMidi_s), 0, 1, 0, 0}, {&__pyx_kp_u_RtMidi_virtual_s, __pyx_k_RtMidi_virtual_s, sizeof(__pyx_k_RtMidi_virtual_s), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_SystemError, __pyx_k_SystemError, sizeof(__pyx_k_SystemError), 0, 0, 1, 1}, {&__pyx_n_u_SystemError, __pyx_k_SystemError, sizeof(__pyx_k_SystemError), 0, 1, 0, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_UnsupportedOperationError, __pyx_k_UnsupportedOperationError, sizeof(__pyx_k_UnsupportedOperationError), 0, 0, 1, 1}, {&__pyx_n_u_UnsupportedOperationError, __pyx_k_UnsupportedOperationError, sizeof(__pyx_k_UnsupportedOperationError), 0, 1, 0, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_u_Virtual_ports_are_not_supported, __pyx_k_Virtual_ports_are_not_supported, sizeof(__pyx_k_Virtual_ports_are_not_supported), 0, 1, 0, 0}, {&__pyx_n_s_active_sense, __pyx_k_active_sense, sizeof(__pyx_k_active_sense), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_kp_u_already_opened_virtual, __pyx_k_already_opened_virtual, sizeof(__pyx_k_already_opened_virtual), 0, 1, 0, 0}, {&__pyx_n_s_api, __pyx_k_api, sizeof(__pyx_k_api), 0, 0, 1, 1}, {&__pyx_n_s_api_v, __pyx_k_api_v, sizeof(__pyx_k_api_v), 0, 0, 1, 1}, {&__pyx_n_u_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 1, 0, 1}, {&__pyx_n_s_cancel_callback, __pyx_k_cancel_callback, sizeof(__pyx_k_cancel_callback), 0, 0, 1, 1}, {&__pyx_n_s_check_port, __pyx_k_check_port, sizeof(__pyx_k_check_port), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_close_port, __pyx_k_close_port, sizeof(__pyx_k_close_port), 0, 0, 1, 1}, {&__pyx_n_u_darwin, __pyx_k_darwin, sizeof(__pyx_k_darwin), 0, 1, 0, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_decode_string, __pyx_k_decode_string, sizeof(__pyx_k_decode_string), 0, 0, 1, 1}, {&__pyx_n_s_default_error_handler, __pyx_k_default_error_handler, sizeof(__pyx_k_default_error_handler), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_encoding, __pyx_k_encoding, sizeof(__pyx_k_encoding), 0, 0, 1, 1}, {&__pyx_n_s_endswith, __pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 0, 1, 1}, {&__pyx_kp_u_error_looking_for_port_name, __pyx_k_error_looking_for_port_name, sizeof(__pyx_k_error_looking_for_port_name), 0, 1, 0, 0}, {&__pyx_kp_u_error_sending_MIDI_message_to_po, __pyx_k_error_sending_MIDI_message_to_po, sizeof(__pyx_k_error_sending_MIDI_message_to_po), 0, 1, 0, 0}, {&__pyx_kp_u_error_sending_MIDI_to_virtual_de, __pyx_k_error_sending_MIDI_to_virtual_de, sizeof(__pyx_k_error_sending_MIDI_to_virtual_de), 0, 1, 0, 0}, {&__pyx_n_s_etype, __pyx_k_etype, sizeof(__pyx_k_etype), 0, 0, 1, 1}, {&__pyx_kp_u_event_parsing_error, __pyx_k_event_parsing_error, sizeof(__pyx_k_event_parsing_error), 0, 1, 0, 0}, {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1}, {&__pyx_n_s_get_api_display_name, __pyx_k_get_api_display_name, sizeof(__pyx_k_get_api_display_name), 0, 0, 1, 1}, {&__pyx_n_u_get_api_display_name, __pyx_k_get_api_display_name, sizeof(__pyx_k_get_api_display_name), 0, 1, 0, 1}, {&__pyx_n_s_get_api_name, __pyx_k_get_api_name, sizeof(__pyx_k_get_api_name), 0, 0, 1, 1}, {&__pyx_n_u_get_api_name, __pyx_k_get_api_name, sizeof(__pyx_k_get_api_name), 0, 1, 0, 1}, {&__pyx_n_s_get_compiled_api, __pyx_k_get_compiled_api, sizeof(__pyx_k_get_compiled_api), 0, 0, 1, 1}, {&__pyx_n_u_get_compiled_api, __pyx_k_get_compiled_api, sizeof(__pyx_k_get_compiled_api), 0, 1, 0, 1}, {&__pyx_n_s_get_compiled_api_by_name, __pyx_k_get_compiled_api_by_name, sizeof(__pyx_k_get_compiled_api_by_name), 0, 0, 1, 1}, {&__pyx_n_u_get_compiled_api_by_name, __pyx_k_get_compiled_api_by_name, sizeof(__pyx_k_get_compiled_api_by_name), 0, 1, 0, 1}, {&__pyx_n_s_get_current_api, __pyx_k_get_current_api, sizeof(__pyx_k_get_current_api), 0, 0, 1, 1}, {&__pyx_n_s_get_port_count, __pyx_k_get_port_count, sizeof(__pyx_k_get_port_count), 0, 0, 1, 1}, {&__pyx_n_s_get_port_name, __pyx_k_get_port_name, sizeof(__pyx_k_get_port_name), 0, 0, 1, 1}, {&__pyx_n_s_get_rtmidi_version, __pyx_k_get_rtmidi_version, sizeof(__pyx_k_get_rtmidi_version), 0, 0, 1, 1}, {&__pyx_n_u_get_rtmidi_version, __pyx_k_get_rtmidi_version, sizeof(__pyx_k_get_rtmidi_version), 0, 1, 0, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_u_ignore, __pyx_k_ignore, sizeof(__pyx_k_ignore), 0, 1, 0, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_u_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 1, 0, 1}, {&__pyx_kp_u_is_invalid, __pyx_k_is_invalid, sizeof(__pyx_k_is_invalid), 0, 1, 0, 0}, {&__pyx_n_u_latin1, __pyx_k_latin1, sizeof(__pyx_k_latin1), 0, 1, 0, 1}, {&__pyx_n_u_macroman, __pyx_k_macroman, sizeof(__pyx_k_macroman), 0, 1, 0, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_kp_u_message_longer_than_3_bytes_but, __pyx_k_message_longer_than_3_bytes_but, sizeof(__pyx_k_message_longer_than_3_bytes_but), 0, 1, 0, 0}, {&__pyx_kp_u_message_must_not_be_empty, __pyx_k_message_must_not_be_empty, sizeof(__pyx_k_message_must_not_be_empty), 0, 1, 0, 0}, {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_kp_u_name_must_be_bytes_or_unicode_st, __pyx_k_name_must_be_bytes_or_unicode_st, sizeof(__pyx_k_name_must_be_bytes_or_unicode_st), 0, 1, 0, 0}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_kp_u_no_ports_available, __pyx_k_no_ports_available, sizeof(__pyx_k_no_ports_available), 0, 1, 0, 0}, {&__pyx_n_u_output, __pyx_k_output, sizeof(__pyx_k_output), 0, 1, 0, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_platform, __pyx_k_platform, sizeof(__pyx_k_platform), 0, 0, 1, 1}, {&__pyx_kp_u_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 1, 0, 0}, {&__pyx_n_u_portNumber, __pyx_k_portNumber, sizeof(__pyx_k_portNumber), 0, 1, 0, 1}, {&__pyx_n_s_port_2, __pyx_k_port_2, sizeof(__pyx_k_port_2), 0, 0, 1, 1}, {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_MidiBase, __pyx_k_pyx_unpickle_MidiBase, sizeof(__pyx_k_pyx_unpickle_MidiBase), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, {&__pyx_n_s_queue_size_limit, __pyx_k_queue_size_limit, sizeof(__pyx_k_queue_size_limit), 0, 0, 1, 1}, {&__pyx_kp_u_r_already_opened_s_port_i, __pyx_k_r_already_opened_s_port_i, sizeof(__pyx_k_r_already_opened_s_port_i), 0, 1, 0, 0}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_rtapi, __pyx_k_rtapi, sizeof(__pyx_k_rtapi), 0, 0, 1, 1}, {&__pyx_n_s_rtmidi__rtmidi, __pyx_k_rtmidi__rtmidi, sizeof(__pyx_k_rtmidi__rtmidi), 0, 0, 1, 1}, {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, {&__pyx_n_s_set_error_callback, __pyx_k_set_error_callback, sizeof(__pyx_k_set_error_callback), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_kp_s_src__rtmidi_pyx, __pyx_k_src__rtmidi_pyx, sizeof(__pyx_k_src__rtmidi_pyx), 0, 0, 1, 0}, {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, {&__pyx_n_s_string_types, __pyx_k_string_types, sizeof(__pyx_k_string_types), 0, 0, 1, 1}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_s_sysex, __pyx_k_sysex, sizeof(__pyx_k_sysex), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_u_thisptr, __pyx_k_thisptr, sizeof(__pyx_k_thisptr), 0, 1, 0, 1}, {&__pyx_n_s_timing, __pyx_k_timing, sizeof(__pyx_k_timing), 0, 0, 1, 1}, {&__pyx_n_s_to_bytes, __pyx_k_to_bytes, sizeof(__pyx_k_to_bytes), 0, 0, 1, 1}, {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0}, {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, {&__pyx_n_u_win, __pyx_k_win, sizeof(__pyx_k_win), 0, 1, 0, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 282, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 291, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 300, __pyx_L1_error) __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(0, 309, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 212, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 229, __pyx_L1_error) __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_n_s_super); if (!__pyx_builtin_super) __PYX_ERR(0, 278, __pyx_L1_error) __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 642, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "src/_rtmidi.pyx":233 * * if not isinstance(name, bytes): * raise TypeError("name must be bytes or (unicode) string.") # <<<<<<<<<<<<<< * * return name */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_name_must_be_bytes_or_unicode_st); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "src/_rtmidi.pyx":642 * """ * if self.get_current_api() == API_WINDOWS_MM: * raise NotImplementedError("Virtual ports are not supported " # <<<<<<<<<<<<<< * "by the Windows MultiMedia API.") * */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Virtual_ports_are_not_supported); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 642, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "src/_rtmidi.pyx":686 * """ * if self.get_current_api() in (API_MACOSX_CORE, API_UNIX_JACK, API_WINDOWS_MM): * raise NotImplementedError( # <<<<<<<<<<<<<< * "API backend does not support changing the client name.") * */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_API_backend_does_not_support_cha); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "src/_rtmidi.pyx":1095 * * if not message: * raise ValueError("'message' must not be empty.") # <<<<<<<<<<<<<< * * if len(message) > 3 and message[0] != 0xF0: */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_message_must_not_be_empty); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 1095, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "src/_rtmidi.pyx":1098 * * if len(message) > 3 and message[0] != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " # <<<<<<<<<<<<<< * "start with 0xF0.") * */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_message_longer_than_3_bytes_but); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 1098, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "src/_rtmidi.pyx":115 * * __all__ = ( * 'API_UNSPECIFIED', 'API_MACOSX_CORE', 'API_LINUX_ALSA', 'API_UNIX_JACK', # <<<<<<<<<<<<<< * 'API_WINDOWS_MM', 'API_RTMIDI_DUMMY', 'ERRORTYPE_DEBUG_WARNING', * 'ERRORTYPE_DRIVER_ERROR', 'ERRORTYPE_INVALID_DEVICE', */ __pyx_tuple__12 = PyTuple_Pack(31, __pyx_n_u_API_UNSPECIFIED, __pyx_n_u_API_MACOSX_CORE, __pyx_n_u_API_LINUX_ALSA, __pyx_n_u_API_UNIX_JACK, __pyx_n_u_API_WINDOWS_MM, __pyx_n_u_API_RTMIDI_DUMMY, __pyx_n_u_ERRORTYPE_DEBUG_WARNING, __pyx_n_u_ERRORTYPE_DRIVER_ERROR, __pyx_n_u_ERRORTYPE_INVALID_DEVICE, __pyx_n_u_ERRORTYPE_INVALID_PARAMETER, __pyx_n_u_ERRORTYPE_INVALID_USE, __pyx_n_u_ERRORTYPE_MEMORY_ERROR, __pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND, __pyx_n_u_ERRORTYPE_SYSTEM_ERROR, __pyx_n_u_ERRORTYPE_THREAD_ERROR, __pyx_n_u_ERRORTYPE_UNSPECIFIED, __pyx_n_u_ERRORTYPE_WARNING, __pyx_n_u_InvalidPortError, __pyx_n_u_InvalidUseError, __pyx_n_u_MemoryAllocationError, __pyx_n_u_MidiIn, __pyx_n_u_MidiOut, __pyx_n_u_NoDevicesError, __pyx_n_u_RtMidiError, __pyx_n_u_SystemError, __pyx_n_u_UnsupportedOperationError, __pyx_n_u_get_api_display_name, __pyx_n_u_get_api_name, __pyx_n_u_get_compiled_api, __pyx_n_u_get_compiled_api_by_name, __pyx_n_u_get_rtmidi_version); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "src/_rtmidi.pyx":223 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_name); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_to_bytes, 223, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 223, __pyx_L1_error) /* "src/_rtmidi.pyx":277 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_msg, __pyx_n_s_type); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_init, 277, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 277, __pyx_L1_error) __pyx_tuple__17 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "src/_rtmidi.pyx":338 * # wrappers for RtMidi's static methods and classes * * def get_api_display_name(api): # <<<<<<<<<<<<<< * """Return the display name of a specified MIDI API. * */ __pyx_tuple__18 = PyTuple_Pack(1, __pyx_n_s_api); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_get_api_display_name, 338, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 338, __pyx_L1_error) /* "src/_rtmidi.pyx":354 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_api); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 354, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_get_api_name, 354, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 354, __pyx_L1_error) /* "src/_rtmidi.pyx":370 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ __pyx_tuple__22 = PyTuple_Pack(2, __pyx_n_s_api_v, __pyx_n_s_i); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_get_compiled_api, 370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 370, __pyx_L1_error) /* "src/_rtmidi.pyx":386 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ __pyx_tuple__24 = PyTuple_Pack(1, __pyx_n_s_name); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 386, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_get_compiled_api_by_name, 386, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 386, __pyx_L1_error) /* "src/_rtmidi.pyx":397 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_get_rtmidi_version, 397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 397, __pyx_L1_error) /* "src/_rtmidi.pyx":402 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ __pyx_tuple__27 = PyTuple_Pack(3, __pyx_n_s_etype, __pyx_n_s_msg, __pyx_n_s_data); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src__rtmidi_pyx, __pyx_n_s_default_error_handler, 402, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 402, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__29 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_MidiBase, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_240 = PyInt_FromLong(240); if (unlikely(!__pyx_int_240)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_152509455 = PyInt_FromLong(152509455L); if (unlikely(!__pyx_int_152509455)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase = &__pyx_vtable_6rtmidi_7_rtmidi_MidiBase; __pyx_vtable_6rtmidi_7_rtmidi_MidiBase.baseptr = (RtMidi *(*)(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *))__pyx_f_6rtmidi_7_rtmidi_8MidiBase_baseptr; if (PyType_Ready(&__pyx_type_6rtmidi_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 431, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_6rtmidi_7_rtmidi_MidiBase.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6rtmidi_7_rtmidi_MidiBase.tp_dictoffset && __pyx_type_6rtmidi_7_rtmidi_MidiBase.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_6rtmidi_7_rtmidi_MidiBase.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_6rtmidi_7_rtmidi_MidiBase.tp_dict, __pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 431, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiBase, (PyObject *)&__pyx_type_6rtmidi_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 431, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6rtmidi_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 431, __pyx_L1_error) __pyx_ptype_6rtmidi_7_rtmidi_MidiBase = &__pyx_type_6rtmidi_7_rtmidi_MidiBase; __pyx_vtabptr_6rtmidi_7_rtmidi_MidiIn = &__pyx_vtable_6rtmidi_7_rtmidi_MidiIn; __pyx_vtable_6rtmidi_7_rtmidi_MidiIn.__pyx_base = *__pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase; __pyx_vtable_6rtmidi_7_rtmidi_MidiIn.__pyx_base.baseptr = (RtMidi *(*)(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *))__pyx_f_6rtmidi_7_rtmidi_6MidiIn_baseptr; __pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_base = __pyx_ptype_6rtmidi_7_rtmidi_MidiBase; if (PyType_Ready(&__pyx_type_6rtmidi_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 757, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_dictoffset && __pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_6rtmidi_7_rtmidi_MidiIn.tp_dict, __pyx_vtabptr_6rtmidi_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 757, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiIn, (PyObject *)&__pyx_type_6rtmidi_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 757, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6rtmidi_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 757, __pyx_L1_error) __pyx_ptype_6rtmidi_7_rtmidi_MidiIn = &__pyx_type_6rtmidi_7_rtmidi_MidiIn; __pyx_vtabptr_6rtmidi_7_rtmidi_MidiOut = &__pyx_vtable_6rtmidi_7_rtmidi_MidiOut; __pyx_vtable_6rtmidi_7_rtmidi_MidiOut.__pyx_base = *__pyx_vtabptr_6rtmidi_7_rtmidi_MidiBase; __pyx_vtable_6rtmidi_7_rtmidi_MidiOut.__pyx_base.baseptr = (RtMidi *(*)(struct __pyx_obj_6rtmidi_7_rtmidi_MidiBase *))__pyx_f_6rtmidi_7_rtmidi_7MidiOut_baseptr; __pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_base = __pyx_ptype_6rtmidi_7_rtmidi_MidiBase; if (PyType_Ready(&__pyx_type_6rtmidi_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 969, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_dictoffset && __pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_6rtmidi_7_rtmidi_MidiOut.tp_dict, __pyx_vtabptr_6rtmidi_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 969, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiOut, (PyObject *)&__pyx_type_6rtmidi_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 969, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6rtmidi_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 969, __pyx_L1_error) __pyx_ptype_6rtmidi_7_rtmidi_MidiOut = &__pyx_type_6rtmidi_7_rtmidi_MidiOut; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_rtmidi(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_rtmidi(void) #else __Pyx_PyMODINIT_FUNC PyInit__rtmidi(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__rtmidi(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__rtmidi(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_rtmidi' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__rtmidi(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_rtmidi", __pyx_methods, __pyx_k_A_Python_binding_for_the_RtMidi, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_rtmidi___rtmidi) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "rtmidi._rtmidi")) { if (unlikely(PyDict_SetItemString(modules, "rtmidi._rtmidi", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "src/_rtmidi.pyx":106 * """ * * import sys # <<<<<<<<<<<<<< * import warnings * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":107 * * import sys * import warnings # <<<<<<<<<<<<<< * * from libcpp cimport bool */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_warnings, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_1) < 0) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":115 * * __all__ = ( * 'API_UNSPECIFIED', 'API_MACOSX_CORE', 'API_LINUX_ALSA', 'API_UNIX_JACK', # <<<<<<<<<<<<<< * 'API_WINDOWS_MM', 'API_RTMIDI_DUMMY', 'ERRORTYPE_DEBUG_WARNING', * 'ERRORTYPE_DRIVER_ERROR', 'ERRORTYPE_INVALID_DEVICE', */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__12) < 0) __PYX_ERR(0, 114, __pyx_L1_error) /* "src/_rtmidi.pyx":128 * ) * * if bytes is str: # <<<<<<<<<<<<<< * string_types = (str, unicode) * else: */ __pyx_t_2 = ((&PyBytes_Type) == (&PyUnicode_Type)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/_rtmidi.pyx":129 * * if bytes is str: * string_types = (str, unicode) # <<<<<<<<<<<<<< * else: * string_types = (str,) */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)(&PyUnicode_Type))); __Pyx_GIVEREF(((PyObject *)(&PyUnicode_Type))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&PyUnicode_Type))); __Pyx_INCREF(((PyObject *)(&PyUnicode_Type))); __Pyx_GIVEREF(((PyObject *)(&PyUnicode_Type))); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)(&PyUnicode_Type))); if (PyDict_SetItem(__pyx_d, __pyx_n_s_string_types, __pyx_t_1) < 0) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":128 * ) * * if bytes is str: # <<<<<<<<<<<<<< * string_types = (str, unicode) * else: */ goto __pyx_L2; } /* "src/_rtmidi.pyx":131 * string_types = (str, unicode) * else: * string_types = (str,) # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)(&PyUnicode_Type))); __Pyx_GIVEREF(((PyObject *)(&PyUnicode_Type))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&PyUnicode_Type))); if (PyDict_SetItem(__pyx_d, __pyx_n_s_string_types, __pyx_t_1) < 0) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L2:; /* "src/_rtmidi.pyx":137 * void py_init() * * py_init() # <<<<<<<<<<<<<< * * # Declarations for RtMidi C++ classes and their methods we use */ py_init(); /* "src/_rtmidi.pyx":223 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" * # 'bytes' == 'str' in Python 2 but a separate type in Python 3 */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_1_to_bytes, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_to_bytes, __pyx_t_1) < 0) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":242 * # export Api enum values to Python * * API_UNSPECIFIED = UNSPECIFIED # <<<<<<<<<<<<<< * API_MACOSX_CORE = MACOSX_CORE * API_LINUX_ALSA = LINUX_ALSA */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::UNSPECIFIED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_UNSPECIFIED, __pyx_t_1) < 0) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":243 * * API_UNSPECIFIED = UNSPECIFIED * API_MACOSX_CORE = MACOSX_CORE # <<<<<<<<<<<<<< * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::MACOSX_CORE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_MACOSX_CORE, __pyx_t_1) < 0) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":244 * API_UNSPECIFIED = UNSPECIFIED * API_MACOSX_CORE = MACOSX_CORE * API_LINUX_ALSA = LINUX_ALSA # <<<<<<<<<<<<<< * API_UNIX_JACK = UNIX_JACK * API_WINDOWS_MM = WINDOWS_MM */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::LINUX_ALSA); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_LINUX_ALSA, __pyx_t_1) < 0) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":245 * API_MACOSX_CORE = MACOSX_CORE * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK # <<<<<<<<<<<<<< * API_WINDOWS_MM = WINDOWS_MM * API_RTMIDI_DUMMY = RTMIDI_DUMMY */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::UNIX_JACK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_UNIX_JACK, __pyx_t_1) < 0) __PYX_ERR(0, 245, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":246 * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK * API_WINDOWS_MM = WINDOWS_MM # <<<<<<<<<<<<<< * API_RTMIDI_DUMMY = RTMIDI_DUMMY * */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::WINDOWS_MM); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_WINDOWS_MM, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":247 * API_UNIX_JACK = UNIX_JACK * API_WINDOWS_MM = WINDOWS_MM * API_RTMIDI_DUMMY = RTMIDI_DUMMY # <<<<<<<<<<<<<< * * # export error values to Python */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::RTMIDI_DUMMY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_RTMIDI_DUMMY, __pyx_t_1) < 0) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":251 * # export error values to Python * * ERRORTYPE_WARNING = ERR_WARNING # <<<<<<<<<<<<<< * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::WARNING); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_WARNING, __pyx_t_1) < 0) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":252 * * ERRORTYPE_WARNING = ERR_WARNING * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING # <<<<<<<<<<<<<< * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DEBUG_WARNING); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_DEBUG_WARNING, __pyx_t_1) < 0) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":253 * ERRORTYPE_WARNING = ERR_WARNING * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED # <<<<<<<<<<<<<< * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND * ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::UNSPECIFIED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_UNSPECIFIED, __pyx_t_1) < 0) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":254 * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND # <<<<<<<<<<<<<< * ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE * ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::NO_DEVICES_FOUND); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND, __pyx_t_1) < 0) __PYX_ERR(0, 254, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":255 * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND * ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE # <<<<<<<<<<<<<< * ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR * ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_DEVICE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_DEVICE, __pyx_t_1) < 0) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":256 * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND * ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE * ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR # <<<<<<<<<<<<<< * ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER * ERRORTYPE_INVALID_USE = ERR_INVALID_USE */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::MEMORY_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_MEMORY_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":257 * ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE * ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR * ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER # <<<<<<<<<<<<<< * ERRORTYPE_INVALID_USE = ERR_INVALID_USE * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_PARAMETER); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_PARAMETER, __pyx_t_1) < 0) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":258 * ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR * ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER * ERRORTYPE_INVALID_USE = ERR_INVALID_USE # <<<<<<<<<<<<<< * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR * ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_USE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_USE, __pyx_t_1) < 0) __PYX_ERR(0, 258, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":259 * ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER * ERRORTYPE_INVALID_USE = ERR_INVALID_USE * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR # <<<<<<<<<<<<<< * ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR * ERRORTYPE_THREAD_ERROR = ERR_THREAD_ERROR */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_DRIVER_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 259, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":260 * ERRORTYPE_INVALID_USE = ERR_INVALID_USE * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR * ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR # <<<<<<<<<<<<<< * ERRORTYPE_THREAD_ERROR = ERR_THREAD_ERROR * */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::SYSTEM_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_SYSTEM_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":261 * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR * ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR * ERRORTYPE_THREAD_ERROR = ERR_THREAD_ERROR # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::THREAD_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_THREAD_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":266 * # custom exceptions * * class RtMidiError(Exception): # <<<<<<<<<<<<<< * """Base general RtMidi exception. * */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_1, __pyx_n_s_RtMidiError, __pyx_n_s_RtMidiError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Base_general_RtMidi_exception_Al); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "src/_rtmidi.pyx":275 * * """ * type = ERR_UNSPECIFIED # <<<<<<<<<<<<<< * * def __init__(self, msg, type=None): */ __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::UNSPECIFIED); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":277 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6rtmidi_7_rtmidi_11RtMidiError_1__init__, 0, __pyx_n_s_RtMidiError___init, NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_7); PyList_Append(__pyx_t_6, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_tuple__17); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":266 * # custom exceptions * * class RtMidiError(Exception): # <<<<<<<<<<<<<< * """Base general RtMidi exception. * */ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_RtMidiError, __pyx_t_1, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_CyFunction_InitClassCell(__pyx_t_6, __pyx_t_7) < 0) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_RtMidiError, __pyx_t_7) < 0) __PYX_ERR(0, 266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":282 * * * class InvalidPortError(RtMidiError, ValueError): # <<<<<<<<<<<<<< * """Raised when an invalid port number is used. * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_INCREF(__pyx_builtin_ValueError); __Pyx_GIVEREF(__pyx_builtin_ValueError); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_builtin_ValueError); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_4, __pyx_n_s_InvalidPortError, __pyx_n_s_InvalidPortError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_when_an_invalid_port_numb); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "src/_rtmidi.pyx":288 * * """ * type = ERR_INVALID_PARAMETER # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_PARAMETER); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 288, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":282 * * * class InvalidPortError(RtMidiError, ValueError): # <<<<<<<<<<<<<< * """Raised when an invalid port number is used. * */ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_InvalidPortError, __pyx_t_4, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidPortError, __pyx_t_7) < 0) __PYX_ERR(0, 282, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/_rtmidi.pyx":291 * * * class InvalidUseError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised when an method call is not allowed in the current state. * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_INCREF(__pyx_builtin_RuntimeError); __Pyx_GIVEREF(__pyx_builtin_RuntimeError); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_RuntimeError); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_1, __pyx_n_s_InvalidUseError, __pyx_n_s_InvalidUseError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_when_an_method_call_is_no); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "src/_rtmidi.pyx":297 * * """ * type = ERR_INVALID_USE # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_USE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 297, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":291 * * * class InvalidUseError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised when an method call is not allowed in the current state. * */ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_InvalidUseError, __pyx_t_1, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidUseError, __pyx_t_7) < 0) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":300 * * * class MemoryAllocationError(RtMidiError, MemoryError): # <<<<<<<<<<<<<< * """Raised if a memory allocation failed on the C++ level. * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_INCREF(__pyx_builtin_MemoryError); __Pyx_GIVEREF(__pyx_builtin_MemoryError); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_builtin_MemoryError); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_4, __pyx_n_s_MemoryAllocationError, __pyx_n_s_MemoryAllocationError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_if_a_memory_allocation_fa); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "src/_rtmidi.pyx":306 * * """ * type = ERR_MEMORY_ERROR # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::MEMORY_ERROR); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":300 * * * class MemoryAllocationError(RtMidiError, MemoryError): # <<<<<<<<<<<<<< * """Raised if a memory allocation failed on the C++ level. * */ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MemoryAllocationError, __pyx_t_4, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MemoryAllocationError, __pyx_t_7) < 0) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/_rtmidi.pyx":309 * * * class SystemError(RtMidiError, OSError): # <<<<<<<<<<<<<< * """Raised if an error happened at the MIDI driver or OS level. * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_INCREF(__pyx_builtin_OSError); __Pyx_GIVEREF(__pyx_builtin_OSError); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_OSError); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_1, __pyx_n_s_SystemError, __pyx_n_s_SystemError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_if_an_error_happened_at_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SystemError, __pyx_t_1, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SystemError, __pyx_t_7) < 0) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":318 * * * class NoDevicesError(SystemError): # <<<<<<<<<<<<<< * """Raised if no MIDI devices are found. * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_4, __pyx_n_s_NoDevicesError, __pyx_n_s_NoDevicesError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_if_no_MIDI_devices_are_fo); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "src/_rtmidi.pyx":324 * * """ * type = ERR_NO_DEVICES_FOUND # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::NO_DEVICES_FOUND); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/_rtmidi.pyx":318 * * * class NoDevicesError(SystemError): # <<<<<<<<<<<<<< * """Raised if no MIDI devices are found. * */ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_NoDevicesError, __pyx_t_4, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NoDevicesError, __pyx_t_7) < 0) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/_rtmidi.pyx":327 * * * class UnsupportedOperationError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised if a method is not supported by the low-level API. * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_INCREF(__pyx_builtin_RuntimeError); __Pyx_GIVEREF(__pyx_builtin_RuntimeError); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_RuntimeError); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_1, __pyx_n_s_UnsupportedOperationError, __pyx_n_s_UnsupportedOperationError, (PyObject *) NULL, __pyx_n_s_rtmidi__rtmidi, __pyx_kp_s_Raised_if_a_method_is_not_suppor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_UnsupportedOperationError, __pyx_t_1, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnsupportedOperationError, __pyx_t_7) < 0) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":338 * # wrappers for RtMidi's static methods and classes * * def get_api_display_name(api): # <<<<<<<<<<<<<< * """Return the display name of a specified MIDI API. * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_3get_api_display_name, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_api_display_name, __pyx_t_1) < 0) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":354 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_5get_api_name, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_api_name, __pyx_t_1) < 0) __PYX_ERR(0, 354, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":370 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_7get_compiled_api, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_compiled_api, __pyx_t_1) < 0) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":386 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_9get_compiled_api_by_name, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_compiled_api_by_name, __pyx_t_1) < 0) __PYX_ERR(0, 386, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":397 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_11get_rtmidi_version, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_rtmidi_version, __pyx_t_1) < 0) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":402 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_13_default_error_handler, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_error_handler, __pyx_t_1) < 0) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":804 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, # <<<<<<<<<<<<<< * unsigned int queue_size_limit=1024): * """Create a new client instance for MIDI input. */ __pyx_k__4 = RtMidi::UNSPECIFIED; /* "src/_rtmidi.pyx":883 * MidiBase.close_port(self) * * close_port.__doc__ == MidiBase.close_port.__doc__ # <<<<<<<<<<<<<< * * def get_message(self): */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_6rtmidi_7_rtmidi_MidiIn, __pyx_n_s_close_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_doc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6rtmidi_7_rtmidi_MidiBase), __pyx_n_s_close_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_doc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":1009 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): # <<<<<<<<<<<<<< * """Create a new client instance for MIDI output. * */ __pyx_k__7 = RtMidi::UNSPECIFIED; /* "(tree fragment)":1 * def __pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6rtmidi_7_rtmidi_15__pyx_unpickle_MidiBase, NULL, __pyx_n_s_rtmidi__rtmidi); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_MidiBase, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/_rtmidi.pyx":1 * # -*- encoding: utf-8 -*- # <<<<<<<<<<<<<< * #cython: embedsignature=True * #cython: language_level=3 */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "string.from_py":13 * * @cname("__pyx_convert_string_from_py_std__in_string") * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< * cdef Py_ssize_t length = 0 * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init rtmidi._rtmidi", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init rtmidi._rtmidi"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #endif /* decode_c_bytes */ static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { if (unlikely((start < 0) | (stop < 0))) { if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } if (stop > length) stop = length; if (unlikely(stop <= start)) return __Pyx_NewRef(__pyx_empty_unicode); length = stop - start; cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyIntCompare */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { if (op1 == op2) { Py_RETURN_TRUE; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = Py_SIZE(op1); const digit* digits = ((PyLongObject*)op1)->ob_digit; if (intval == 0) { if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } else if (intval < 0) { if (size >= 0) Py_RETURN_FALSE; intval = -intval; size = -size; } else { if (size <= 0) Py_RETURN_FALSE; } uintval = (unsigned long) intval; #if PyLong_SHIFT * 4 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 4)) { unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 3 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 3)) { unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 2 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 2)) { unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 1 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 1)) { unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } return ( PyObject_RichCompare(op1, op2, Py_EQ)); } /* PyObjectFormatAndDecref */ static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { if (unlikely(!s)) return NULL; if (likely(PyUnicode_CheckExact(s))) return s; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(s))) { PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); Py_DECREF(s); return result; } #endif return __Pyx_PyObject_FormatAndDecref(s, f); } static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { PyObject *result = PyObject_Format(s, f); Py_DECREF(s); return result; } /* PyUnicode_Unicode */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { if (unlikely(obj == Py_None)) obj = __pyx_kp_u_None; return __Pyx_NewRef(obj); } /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, CYTHON_UNUSED Py_UCS4 max_char) { #if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *result_uval; int result_ukind; Py_ssize_t i, char_pos; void *result_udata; #if CYTHON_PEP393_ENABLED result_uval = PyUnicode_New(result_ulength, max_char); if (unlikely(!result_uval)) return NULL; result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; result_udata = PyUnicode_DATA(result_uval); #else result_uval = PyUnicode_FromUnicode(NULL, result_ulength); if (unlikely(!result_uval)) return NULL; result_ukind = sizeof(Py_UNICODE); result_udata = PyUnicode_AS_UNICODE(result_uval); #endif char_pos = 0; for (i=0; i < value_count; i++) { int ukind; Py_ssize_t ulength; void *udata; PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); if (unlikely(__Pyx_PyUnicode_READY(uval))) goto bad; ulength = __Pyx_PyUnicode_GET_LENGTH(uval); if (unlikely(!ulength)) continue; if (unlikely(char_pos + ulength < 0)) goto overflow; ukind = __Pyx_PyUnicode_KIND(uval); udata = __Pyx_PyUnicode_DATA(uval); if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind)); } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); #else Py_ssize_t j; for (j=0; j < ulength; j++) { Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); } #endif } char_pos += ulength; } return result_uval; overflow: PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); bad: Py_DECREF(result_uval); return NULL; #else result_ulength++; value_count++; return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #endif } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* PyIntCompare */ static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { if (op1 == op2) { Py_RETURN_FALSE; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); if (a != b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = Py_SIZE(op1); const digit* digits = ((PyLongObject*)op1)->ob_digit; if (intval == 0) { if (size != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } else if (intval < 0) { if (size >= 0) Py_RETURN_TRUE; intval = -intval; size = -size; } else { if (size <= 0) Py_RETURN_TRUE; } uintval = (unsigned long) intval; #if PyLong_SHIFT * 4 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 4)) { unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 3 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 3)) { unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 2 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 2)) { unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 1 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 1)) { unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); if (unequal != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); if ((double)a != (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } return ( PyObject_RichCompare(op1, op2, Py_NE)); } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; #if CYTHON_USE_PYTYPE_LOOKUP if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #else if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); for (i=0; i < nbases; i++) { PyTypeObject *tmptype; PyObject *tmp = PyTuple_GET_ITEM(bases, i); tmptype = Py_TYPE(tmp); #if PY_MAJOR_VERSION < 3 if (tmptype == &PyClass_Type) continue; #endif if (!metaclass) { metaclass = tmptype; continue; } if (PyType_IsSubtype(metaclass, tmptype)) continue; if (PyType_IsSubtype(tmptype, metaclass)) { metaclass = tmptype; continue; } PyErr_SetString(PyExc_TypeError, "metaclass conflict: " "the metaclass of a derived class " "must be a (non-strict) subclass " "of the metaclasses of all its bases"); return NULL; } if (!metaclass) { #if PY_MAJOR_VERSION < 3 metaclass = &PyClass_Type; #else metaclass = &PyType_Type; #endif } Py_INCREF((PyObject*) metaclass); return (PyObject*) metaclass; } /* FetchCommonType */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CythonFunctionShared */ #include static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) { if (unlikely(op->func_doc == NULL)) { if (op->func.m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); #else op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp = op->func_doc; if (value == NULL) { value = Py_None; } Py_INCREF(value); op->func_doc = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_name == NULL)) { #if PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); #else op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = op->func_name; Py_INCREF(value); op->func_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->func_qualname; Py_INCREF(value); op->func_qualname = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) { PyObject *self; self = m->func_closure; if (self == NULL) self = Py_None; Py_INCREF(self); return self; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } tmp = op->func_dict; Py_INCREF(value); op->func_dict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyTuple_Check(value)) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } Py_INCREF(value); tmp = op->defaults_tuple; op->defaults_tuple = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } Py_INCREF(value); tmp = op->defaults_kwdict; op->defaults_kwdict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value || value == Py_None) { value = NULL; } else if (!PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); tmp = op->func_annotations; op->func_annotations = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromString(m->func.m_ml->ml_name); #else return PyString_FromString(m->func.m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { if (unlikely(op == NULL)) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; op->func_classobj = NULL; op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); Py_CLEAR(m->func.m_module); Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); Py_CLEAR(m->func_classobj); Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyObject_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); Py_VISIT(m->func.m_module); Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); Py_VISIT(m->func_classobj); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { #if PY_MAJOR_VERSION < 3 __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); return func; } if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { if (type == NULL) type = (PyObject *)(Py_TYPE(obj)); return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); } if (obj == Py_None) obj = NULL; #endif return __Pyx_PyMethod_New(func, obj, type); } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; Py_ssize_t size; switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 0)) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "__Pyx_CyFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; argc = PyTuple_GET_SIZE(args); new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_CallAsMethod, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_CyFunction_descr_get, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (unlikely(__pyx_CyFunctionType == NULL)) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_Malloc(size); if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* CythonFunction */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } /* Py3ClassCreate */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); if (prep) { PyObject *pargs = PyTuple_Pack(2, name, bases); if (unlikely(!pargs)) { Py_DECREF(prep); return NULL; } ns = PyObject_Call(prep, pargs, mkw); Py_DECREF(prep); Py_DECREF(pargs); } else { if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; PyErr_Clear(); ns = PyDict_New(); } } else { ns = PyDict_New(); } if (unlikely(!ns)) return NULL; if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; return ns; bad: Py_DECREF(ns); return NULL; } static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { PyObject *result, *margs; PyObject *owned_metaclass = NULL; if (allow_py2_metaclass) { owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); if (owned_metaclass) { metaclass = owned_metaclass; } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { PyErr_Clear(); } else { return NULL; } } if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); Py_XDECREF(owned_metaclass); if (unlikely(!metaclass)) return NULL; owned_metaclass = metaclass; } margs = PyTuple_Pack(3, name, bases, dict); if (unlikely(!margs)) { result = NULL; } else { result = PyObject_Call(metaclass, margs, mkw); Py_DECREF(margs); } Py_XDECREF(owned_metaclass); return result; } /* CyFunctionClassCell */ static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj) { Py_ssize_t i, count = PyList_GET_SIZE(cyfunctions); for (i = 0; i < count; i++) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyList_GET_ITEM(cyfunctions, i); #else PySequence_ITEM(cyfunctions, i); if (unlikely(!m)) return -1; #endif Py_INCREF(classobj); m->func_classobj = classobj; #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF((PyObject*)m); #endif } return 0; } /* GetNameInClass */ static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) { PyObject *result; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); __Pyx_GetModuleGlobalNameUncached(result, name); return result; } static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { PyObject *result; result = __Pyx_PyObject_GetAttrStr(nmspace, name); if (!result) { result = __Pyx_GetGlobalNameAfterAttributeLookup(name); } return result; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(enum RtMidi::Api value) { const enum RtMidi::Api neg_one = (enum RtMidi::Api) ((enum RtMidi::Api) 0 - (enum RtMidi::Api) 1), const_zero = (enum RtMidi::Api) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum RtMidi::Api) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum RtMidi::Api) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidi::Api) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum RtMidi::Api) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidi::Api) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum RtMidi::Api), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(enum RtMidiError::Type value) { const enum RtMidiError::Type neg_one = (enum RtMidiError::Type) ((enum RtMidiError::Type) 0 - (enum RtMidiError::Type) 1), const_zero = (enum RtMidiError::Type) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum RtMidiError::Type) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum RtMidiError::Type) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidiError::Type) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum RtMidiError::Type) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidiError::Type) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum RtMidiError::Type), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value) { const unsigned char neg_one = (unsigned char) ((unsigned char) 0 - (unsigned char) 1), const_zero = (unsigned char) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned char) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned char) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned char) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned char), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) case -2: if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; } #endif if (sizeof(unsigned int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned int) -1; } } else { unsigned int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned int) -1; val = __Pyx_PyInt_As_unsigned_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntFromPy */ static CYTHON_INLINE enum RtMidi::Api __Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(PyObject *x) { const enum RtMidi::Api neg_one = (enum RtMidi::Api) ((enum RtMidi::Api) 0 - (enum RtMidi::Api) 1), const_zero = (enum RtMidi::Api) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(enum RtMidi::Api) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (enum RtMidi::Api) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (enum RtMidi::Api) 0; case 1: __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, digit, digits[0]) case 2: if (8 * sizeof(enum RtMidi::Api) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) >= 2 * PyLong_SHIFT) { return (enum RtMidi::Api) (((((enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0])); } } break; case 3: if (8 * sizeof(enum RtMidi::Api) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) >= 3 * PyLong_SHIFT) { return (enum RtMidi::Api) (((((((enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0])); } } break; case 4: if (8 * sizeof(enum RtMidi::Api) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) >= 4 * PyLong_SHIFT) { return (enum RtMidi::Api) (((((((((enum RtMidi::Api)digits[3]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (enum RtMidi::Api) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(enum RtMidi::Api) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(enum RtMidi::Api, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidi::Api) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(enum RtMidi::Api, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (enum RtMidi::Api) 0; case -1: __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, digit, +digits[0]) case -2: if (8 * sizeof(enum RtMidi::Api) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 2 * PyLong_SHIFT) { return (enum RtMidi::Api) (((enum RtMidi::Api)-1)*(((((enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; case 2: if (8 * sizeof(enum RtMidi::Api) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 2 * PyLong_SHIFT) { return (enum RtMidi::Api) ((((((enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; case -3: if (8 * sizeof(enum RtMidi::Api) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 3 * PyLong_SHIFT) { return (enum RtMidi::Api) (((enum RtMidi::Api)-1)*(((((((enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; case 3: if (8 * sizeof(enum RtMidi::Api) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 3 * PyLong_SHIFT) { return (enum RtMidi::Api) ((((((((enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; case -4: if (8 * sizeof(enum RtMidi::Api) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 4 * PyLong_SHIFT) { return (enum RtMidi::Api) (((enum RtMidi::Api)-1)*(((((((((enum RtMidi::Api)digits[3]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; case 4: if (8 * sizeof(enum RtMidi::Api) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum RtMidi::Api) - 1 > 4 * PyLong_SHIFT) { return (enum RtMidi::Api) ((((((((((enum RtMidi::Api)digits[3]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[2]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[1]) << PyLong_SHIFT) | (enum RtMidi::Api)digits[0]))); } } break; } #endif if (sizeof(enum RtMidi::Api) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(enum RtMidi::Api, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(enum RtMidi::Api) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(enum RtMidi::Api, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else enum RtMidi::Api val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (enum RtMidi::Api) -1; } } else { enum RtMidi::Api val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (enum RtMidi::Api) -1; val = __Pyx_PyInt_As_enum__RtMidi_3a__3a_Api(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to enum RtMidi::Api"); return (enum RtMidi::Api) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to enum RtMidi::Api"); return (enum RtMidi::Api) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntFromPy */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) ((size_t) 0 - (size_t) 1), const_zero = (size_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(size_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (size_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (size_t) 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0]) case 2: if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) { return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; case 3: if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) { return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; case 4: if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) { return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (size_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(size_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (size_t) 0; case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0]) case -2: if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 2: if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case -3: if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 3: if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case -4: if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 4: if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; } #endif if (sizeof(size_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else size_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (size_t) -1; } } else { size_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (size_t) -1; val = __Pyx_PyInt_As_size_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to size_t"); return (size_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *x) { const unsigned char neg_one = (unsigned char) ((unsigned char) 0 - (unsigned char) 1), const_zero = (unsigned char) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned char) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned char) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned char) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned char, digit, digits[0]) case 2: if (8 * sizeof(unsigned char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) >= 2 * PyLong_SHIFT) { return (unsigned char) (((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; case 3: if (8 * sizeof(unsigned char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) >= 3 * PyLong_SHIFT) { return (unsigned char) (((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; case 4: if (8 * sizeof(unsigned char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) >= 4 * PyLong_SHIFT) { return (unsigned char) (((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned char) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned char) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned char) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned char, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned char, digit, +digits[0]) case -2: if (8 * sizeof(unsigned char) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT) { return (unsigned char) (((unsigned char)-1)*(((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT) { return (unsigned char) ((((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT) { return (unsigned char) (((unsigned char)-1)*(((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT) { return (unsigned char) ((((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 4 * PyLong_SHIFT) { return (unsigned char) (((unsigned char)-1)*(((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned char) - 1 > 4 * PyLong_SHIFT) { return (unsigned char) ((((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; } #endif if (sizeof(unsigned char) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned char val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned char) -1; } } else { unsigned char val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned char) -1; val = __Pyx_PyInt_As_unsigned_char(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned char"); return (unsigned char) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned char"); return (unsigned char) -1; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; ip) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611765224.0 python-rtmidi-1.4.7/src/_rtmidi.pyx0000644000175000001440000011426700000000000016355 0ustar00chrisusers# -*- encoding: utf-8 -*- #cython: embedsignature=True #cython: language_level=3 # # rtmidi.pyx # """A Python binding for the RtMidi C++ library implemented using Cython. Overview ======== **RtMidi** is a set of C++ classes which provides a concise and simple, cross-platform API (Application Programming Interface) for realtime MIDI input / output across Linux (ALSA & JACK), macOS / OS X (CoreMIDI & JACK), and Windows (MultiMedia System) operating systems. **python-rtmidi** is a Python binding for RtMidi implemented using Cython_ and provides a thin wrapper around the RtMidi C++ interface. The API is basically the same as the C++ one but with the naming scheme of classes, methods and parameters adapted to the Python PEP-8 conventions and requirements of the Python package naming structure. **python-rtmidi** supports Python 3 (3.6, 3.7, 3.8, and 3.9). Usage example ============= Here's a short example of how to use **python-rtmidi** to open the first available MIDI output port and send a middle C note on MIDI channel 1:: import time import rtmidi midiout = rtmidi.MidiOut() available_ports = midiout.get_ports() if available_ports: midiout.open_port(0) else: midiout.open_virtual_port("My virtual output") with midiout: note_on = [0x90, 60, 112] # channel 1, middle C, velocity 112 note_off = [0x80, 60, 0] midiout.send_message(note_on) time.sleep(0.5) midiout.send_message(note_off) time.sleep(0.1) del midiout Constants ========= Low-level APIs -------------- These constants are returned by the ``get_compiled_api`` function and the ``MidiIn.get_current_api`` resp. ``MidiOut.get_current_api`` methods and are used to specify the low-level MIDI backend API to use when creating a ``MidiIn`` or ``MidiOut`` instance. ``API_UNSPECIFIED`` Use first compiled-in API, which has any input resp. output ports ``API_MACOSX_CORE`` macOS (OS X) CoreMIDI ``API_LINUX_ALSA`` Linux ALSA ``API_UNIX_JACK`` Jack Client ``API_WINDOWS_MM`` Windows MultiMedia ``API_RTMIDI_DUMMY`` RtMidi Dummy API (used when no suitable API was found) Error types ----------- These constants are passed as the first argument to an error handler function registered with ``set_error_callback`` method of a ``MidiIn`` or ``MidiOut`` instance. For the meaning of each value, please see the `RtMidi API reference`_. * ``ERRORTYPE_DEBUG_WARNING`` * ``ERRORTYPE_DRIVER_ERROR`` * ``ERRORTYPE_INVALID_DEVICE`` * ``ERRORTYPE_INVALID_PARAMETER`` * ``ERRORTYPE_INVALID_USE`` * ``ERRORTYPE_MEMORY_ERROR`` * ``ERRORTYPE_NO_DEVICES_FOUND`` * ``ERRORTYPE_SYSTEM_ERROR`` * ``ERRORTYPE_THREAD_ERROR`` * ``ERRORTYPE_UNSPECIFIED`` * ``ERRORTYPE_WARNING`` .. _cython: http://cython.org/ .. _rtmidi api reference: http://www.music.mcgill.ca/~gary/rtmidi/classRtMidiError.html """ import sys import warnings from libcpp cimport bool from libcpp.string cimport string from libcpp.vector cimport vector __all__ = ( 'API_UNSPECIFIED', 'API_MACOSX_CORE', 'API_LINUX_ALSA', 'API_UNIX_JACK', 'API_WINDOWS_MM', 'API_RTMIDI_DUMMY', 'ERRORTYPE_DEBUG_WARNING', 'ERRORTYPE_DRIVER_ERROR', 'ERRORTYPE_INVALID_DEVICE', 'ERRORTYPE_INVALID_PARAMETER', 'ERRORTYPE_INVALID_USE', 'ERRORTYPE_MEMORY_ERROR', 'ERRORTYPE_NO_DEVICES_FOUND', 'ERRORTYPE_SYSTEM_ERROR', 'ERRORTYPE_THREAD_ERROR', 'ERRORTYPE_UNSPECIFIED', 'ERRORTYPE_WARNING', 'InvalidPortError', 'InvalidUseError', 'MemoryAllocationError', 'MidiIn', 'MidiOut', 'NoDevicesError', 'RtMidiError', 'SystemError', 'UnsupportedOperationError', 'get_api_display_name', 'get_api_name', 'get_compiled_api', 'get_compiled_api_by_name', 'get_rtmidi_version' ) if bytes is str: string_types = (str, unicode) else: string_types = (str,) cdef extern from "pyinit.h": void py_init() py_init() # Declarations for RtMidi C++ classes and their methods we use cdef extern from "RtMidi.h": # Enums nested in classes are apparently not supported by Cython yet # therefore we need to use the following work-around. # https://groups.google.com/d/msg/cython-users/monwJxJCb-g/k_h1rcU-3TgJ cdef enum Api "RtMidi::Api": UNSPECIFIED "RtMidi::UNSPECIFIED" MACOSX_CORE "RtMidi::MACOSX_CORE" LINUX_ALSA "RtMidi::LINUX_ALSA" UNIX_JACK "RtMidi::UNIX_JACK" WINDOWS_MM "RtMidi::WINDOWS_MM" RTMIDI_DUMMY "RtMidi::RTMIDI_DUMMY" cdef enum ErrorType "RtMidiError::Type": ERR_WARNING "RtMidiError::WARNING" ERR_DEBUG_WARNING "RtMidiError::DEBUG_WARNING" ERR_UNSPECIFIED "RtMidiError::UNSPECIFIED" ERR_NO_DEVICES_FOUND "RtMidiError::NO_DEVICES_FOUND" ERR_INVALID_DEVICE "RtMidiError::INVALID_DEVICE" ERR_MEMORY_ERROR "RtMidiError::MEMORY_ERROR" ERR_INVALID_PARAMETER "RtMidiError::INVALID_PARAMETER" ERR_INVALID_USE "RtMidiError::INVALID_USE" ERR_DRIVER_ERROR "RtMidiError::DRIVER_ERROR" ERR_SYSTEM_ERROR "RtMidiError::SYSTEM_ERROR" ERR_THREAD_ERROR "RtMidiError::THREAD_ERROR" # Another work-around for calling C++ static methods: cdef string RtMidi_getApiDisplayName "RtMidi::getApiDisplayName"(Api rtapi) cdef string RtMidi_getApiName "RtMidi::getApiName"(Api rtapi) cdef void RtMidi_getCompiledApi "RtMidi::getCompiledApi"(vector[Api] &apis) cdef Api RtMidi_getCompiledApiByName "RtMidi::getCompiledApiByName"(string) cdef string RtMidi_getVersion "RtMidi::getVersion"() ctypedef void (*RtMidiCallback)(double timeStamp, vector[unsigned char] *message, void *userData) ctypedef void (*RtMidiErrorCallback)(ErrorType errorType, const string errorText, void *userData) except * cdef cppclass RtMidi: void closePort() except * unsigned int getPortCount() except * string getPortName(unsigned int portNumber) except * void openPort(unsigned int portNumber, string &portName) except * void openVirtualPort(string portName) except * void setClientName(string &clientName) except * void setErrorCallback(RtMidiErrorCallback callback, void *userData) except * void setPortName(string &portName) except * cdef cppclass RtMidiIn(RtMidi): Api RtMidiIn(Api rtapi, string clientName, unsigned int queueSizeLimit) except + void cancelCallback() except * Api getCurrentApi() double getMessage(vector[unsigned char] *message) except * void ignoreTypes(bool midiSysex, bool midiTime, bool midiSense) except * void setCallback(RtMidiCallback callback, void *data) except * cdef cppclass RtMidiOut(RtMidi): Api RtMidiOut(Api rtapi, string clientName) except + Api getCurrentApi() void sendMessage(vector[unsigned char] *message) except * # internal functions cdef void _cb_func(double delta_time, vector[unsigned char] *msg_v, void *cb_info) with gil: """Wrapper for a Python callback function for MIDI input.""" func, data = ( cb_info) message = [msg_v.at(i) for i in range(msg_v.size())] func((message, delta_time), data) cdef void _cb_error_func(ErrorType errorType, const string &errorText, void *cb_info) except * with gil: """Wrapper for a Python callback function for errors.""" func, data, decoder = ( cb_info) func(errorType, decoder(errorText), data) def _to_bytes(name): """Convert a unicode (Python 2) or str (Python 3) object into bytes.""" # 'bytes' == 'str' in Python 2 but a separate type in Python 3 if isinstance(name, string_types): try: name = bytes(name, 'utf-8') # Python 3 except TypeError: name = name.encode('utf-8') # Python 2 if not isinstance(name, bytes): raise TypeError("name must be bytes or (unicode) string.") return name # Public API # export Api enum values to Python API_UNSPECIFIED = UNSPECIFIED API_MACOSX_CORE = MACOSX_CORE API_LINUX_ALSA = LINUX_ALSA API_UNIX_JACK = UNIX_JACK API_WINDOWS_MM = WINDOWS_MM API_RTMIDI_DUMMY = RTMIDI_DUMMY # export error values to Python ERRORTYPE_WARNING = ERR_WARNING ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND ERRORTYPE_INVALID_DEVICE = ERR_INVALID_DEVICE ERRORTYPE_MEMORY_ERROR = ERR_MEMORY_ERROR ERRORTYPE_INVALID_PARAMETER = ERR_INVALID_PARAMETER ERRORTYPE_INVALID_USE = ERR_INVALID_USE ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR ERRORTYPE_THREAD_ERROR = ERR_THREAD_ERROR # custom exceptions class RtMidiError(Exception): """Base general RtMidi exception. All other exceptions in this module derive form this exception. Instances have a ``type`` attribute that maps to one of the ``ERRORTYPE_*`` constants. """ type = ERR_UNSPECIFIED def __init__(self, msg, type=None): super().__init__(msg) self.type = self.type if type is None else type class InvalidPortError(RtMidiError, ValueError): """Raised when an invalid port number is used. Also derives from ``ValueError``. """ type = ERR_INVALID_PARAMETER class InvalidUseError(RtMidiError, RuntimeError): """Raised when an method call is not allowed in the current state. Also derives from ``RuntimeError``. """ type = ERR_INVALID_USE class MemoryAllocationError(RtMidiError, MemoryError): """Raised if a memory allocation failed on the C++ level. Also derives from ``MemoryError``. """ type = ERR_MEMORY_ERROR class SystemError(RtMidiError, OSError): """Raised if an error happened at the MIDI driver or OS level. Also derives from ``OSError``. """ pass class NoDevicesError(SystemError): """Raised if no MIDI devices are found. Derives from ``rtmidi.SystemError``. """ type = ERR_NO_DEVICES_FOUND class UnsupportedOperationError(RtMidiError, RuntimeError): """Raised if a method is not supported by the low-level API. Also derives from ``RuntimeError``. """ pass # wrappers for RtMidi's static methods and classes def get_api_display_name(api): """Return the display name of a specified MIDI API. This returns a long name used for display purposes. The ``api`` should be given as the one of ``API_*`` constants in the module namespace, e.g.:: display_name = rtmidi.get_api_display_name(rtmidi.API_UNIX_JACK) If the API is unknown, this function will return the empty string. """ return RtMidi_getApiDisplayName(api).decode('utf-8') def get_api_name(api): """Return the name of a specified MIDI API. This returns a short lower-case name used for identification purposes. The ``api`` should be given as the one of ``API_*`` constants in the module namespace, e.g.:: name = rtmidi.get_api_name(rtmidi.API_UNIX_JACK) If the API is unknown, this function will return the empty string. """ return RtMidi_getApiName(api).decode('utf-8') def get_compiled_api(): """Return a list of low-level MIDI backend APIs this module supports. Check for support for a particular API by using the ``API_*`` constants in the module namespace, i.e.:: if rtmidi.API_UNIX_JACK in rtmidi.get_compiled_api(): ... """ cdef vector[Api] api_v RtMidi_getCompiledApi(api_v) return [api_v[i] for i in range(api_v.size())] def get_compiled_api_by_name(name): """Return the compiled MIDI API having the given name. A case insensitive comparison will check the specified name against the list of compiled APIs, and return the one which matches. On failure, the function returns ``API_UNSPECIFIED``. """ return RtMidi_getCompiledApiByName(_to_bytes(name)) def get_rtmidi_version(): """Return the version string of the wrapped RtMidi library.""" return RtMidi_getVersion().decode('utf-8') def _default_error_handler(etype, msg, data=None): if etype == ERR_MEMORY_ERROR: raise MemoryAllocationError(msg) elif etype == ERR_INVALID_PARAMETER: raise InvalidPortError(msg) elif etype in (ERR_DRIVER_ERROR, ERR_SYSTEM_ERROR, ERR_THREAD_ERROR): raise SystemError(msg, type=etype) elif etype in (ERR_WARNING, ERR_DEBUG_WARNING): if 'portNumber' in msg and msg.endswith('is invalid.'): raise InvalidPortError(msg) elif msg.endswith('no ports available!'): raise InvalidPortError(msg) elif msg.endswith('error looking for port name!'): raise InvalidPortError(msg) elif msg.endswith('event parsing error!'): raise ValueError(msg) elif msg.endswith('error sending MIDI message to port.'): raise SystemError(msg, type=ERR_DRIVER_ERROR) elif msg.endswith('error sending MIDI to virtual destinations.'): raise SystemError(msg, type=ERR_DRIVER_ERROR) elif msg.endswith('JACK server not running?'): raise SystemError(msg, type=ERR_DRIVER_ERROR) else: warnings.warn(msg) return raise RtMidiError(msg, type=etype) cdef class MidiBase: cdef object _port cdef object _error_callback cdef object _deleted cdef RtMidi* baseptr(self): return NULL # context management def __enter__(self): """Support context manager protocol. This means you can use ``MidiIn`` / ``MidiOut`` instances like this: : midiout = MidiIn() midiout.open_port(0) with midiout: midiout.send_message([...]) and ``midiout.close_port()`` will be called automatically when exiting the ``with`` block. Since ``open_port()`` also returns the instance, you can even do: : midiout = MidiIn() with midiout.open_port(0): midiout.send_message([...]) """ return self def __exit__(self, *exc_info): """Support context manager protocol. This method is called when using a ``MidiIn`` / ``MidiOut`` instance as a context manager and closes open ports when exiting the ``with`` block. """ self.close_port() def _check_port(self): inout = "input" if isinstance(self, MidiIn) else "output" if self._port == -1: raise InvalidUseError("%r already opened virtual %s port." % (self, inout)) elif self._port is not None: raise InvalidUseError("%r already opened %s port %i." % (self, inout, self._port)) return inout def _decode_string(self, s, encoding='auto'): """Decode given byte string with given encoding.""" if encoding == 'auto': if sys.platform.startswith('win'): encoding = 'latin1' elif (self.get_current_api() == API_MACOSX_CORE and sys.platform == 'darwin'): encoding = 'macroman' else: encoding = 'utf-8' return s.decode(encoding, "ignore") def get_port_count(self): """Return the number of available MIDI input or output ports.""" return self.baseptr().getPortCount() def get_port_name(self, unsigned int port, encoding='auto'): """Return the name of the MIDI input or output port with given number. Ports are numbered from zero, separately for input and output ports. The number of available ports is returned by the ``get_port_count`` method. The port name is decoded to a (unicode) string with the encoding given by ``encoding``. If ``encoding`` is ``"auto"`` (the default), then an appropriate encoding is chosen based on the system and the used backend API. If ``encoding`` is ``None``, the name is returned un-decoded, i.e. as type ``str`` in Python 2 or ``bytes`` in Python 3. """ cdef string name = self.baseptr().getPortName(port) if len(name): return self._decode_string(name, encoding) if encoding else name def get_ports(self, encoding='auto'): """Return a list of names of available MIDI input or output ports. The list index of each port name corresponds to its port number. The port names are decoded to (unicode) strings with the encoding given by ``encoding``. If ``encoding`` is ``"auto"`` (the default), then an appropriate encoding is chosen based on the system and the used backend API. If ``encoding`` is ``None``, the names are returned un-decoded, i.e. as type ``str`` in Python 2 or ``bytes`` in Python 3. """ return [self.get_port_name(p, encoding=encoding) for p in range(self.get_port_count())] def is_port_open(self): """Return ``True`` if a port has been opened and ``False`` if not. .. note:: The ``isPortOpen`` method of the RtMidi C++ library does not return ``True`` when a virtual port has been openend. The python-rtmidi implementation, on the other hand, does. """ return self._port is not None def open_port(self, unsigned int port=0, name=None): """Open the MIDI input or output port with the given port number. Only one port can be opened per ``MidiIn`` or ``MidiOut`` instance. An ``InvalidUseError`` exception is raised if an attempt is made to open a port on a ``MidiIn`` or ``MidiOut`` instance, which already opened a (virtual) port. You can optionally pass a name for the RtMidi port with the ``name`` keyword or the second positional argument. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. The default name is "RtMidi input" resp. "RtMidi output". .. note:: Closing a port and opening it again with a different name does not change the port name. To change the port name, use the ``set_port_name`` method where supported, or delete its instance, create a new one and open the port again giving a different name. Exceptions: ``InvalidPortError`` Raised when an invalid port number is passed. ``InvalidUseError`` Raised when trying to open a MIDI port when a (virtual) port has already been opened by this instance. ``TypeError`` Raised when an incompatible value type is passed for the ``port`` or ``name`` parameter. """ inout = self._check_port() if name is None: name = "RtMidi %s" % inout self.baseptr().openPort(port, _to_bytes(name)) self._port = port return self def open_virtual_port(self, name=None): """Open a virtual MIDI input or output port. Only one port can be opened per ``MidiIn`` or ``MidiOut`` instance. An ``InvalidUseError`` exception is raised if an attempt is made to open a port on a ``MidiIn`` or ``MidiOut`` instance, which already opened a (virtual) port. A virtual port is not connected to a physical MIDI device or system port when first opened. You can connect it to another MIDI output with the OS-dependent tools provided by the low-level MIDI framework, e.g. ``aconnect`` for ALSA, ``jack_connect`` for JACK, or the Audio & MIDI settings dialog for CoreMIDI. .. note:: Virtual ports are not supported by some backend APIs, namely the Windows MultiMedia API. You can use special MIDI drivers like `MIDI Yoke`_ or loopMIDI_ to provide hardware-independent virtual MIDI ports as an alternative. You can optionally pass a name for the RtMidi port with the ``name`` keyword or the second positional argument. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. The default name is "RtMidi virtual input" resp. "RtMidi virtual output". .. note:: Closing a port and opening it again with a different name does not change the port name. To change the port name, use the ``set_port_name`` method where supported, or delete its instance, create a new one and open the port again giving a different name. Also, to close a virtual input port, you have to delete its ``MidiIn`` or ``MidiOut`` instance. Exceptions: ``InvalidUseError`` Raised when trying to open a virtual port when a (virtual) port has already been opened by this instance. ``TypeError`` Raised when an incompatible value type is passed for the ``name`` parameter. ``UnsupportedOperationError`` Raised when trying to open a virtual MIDI port with the Windows MultiMedia API, which doesn't support virtual ports. .. _midi yoke: http://www.midiox.com/myoke.htm .. _loopmidi: http://www.tobias-erichsen.de/software/loopmidi.html """ if self.get_current_api() == API_WINDOWS_MM: raise NotImplementedError("Virtual ports are not supported " "by the Windows MultiMedia API.") inout = self._check_port() self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) if name is None else name)) self._port = -1 return self def close_port(self): """Close the MIDI input or output port opened via ``open_port``. It is safe to call this method repeatedly or if no port has been opened (yet) by this instance. Also cancels a callback function set with ``set_callback``. To close a virtual port opened via ``open_virtual_port``, you have to delete its ``MidiIn`` or ``MidiOut`` instance. """ if self._port != -1: self._port = None self.baseptr().closePort() def set_client_name(self, name): """Set the name of the MIDI client. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. Currently only supported by the ALSA API backend. Exceptions: ``TypeError`` Raised when an incompatible value type is passed for the ``name`` parameter. ``UnsupportedOperationError`` Raised when trying the backend API does not support changing the client name. """ if self.get_current_api() in (API_MACOSX_CORE, API_UNIX_JACK, API_WINDOWS_MM): raise NotImplementedError( "API backend does not support changing the client name.") self.baseptr().setClientName(_to_bytes(name)) def set_port_name(self, name): """Set the name of the currently opened port. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. Currently only supported by the ALSA and JACK API backends. Exceptions: ``InvalidUseError`` Raised when no port is currently opened. ``TypeError`` Raised when an incompatible value type is passed for the ``name`` parameter. ``UnsupportedOperationError`` Raised when trying the backend API does not support changing the port name. """ if self.get_current_api() in (API_MACOSX_CORE, API_WINDOWS_MM): raise UnsupportedOperationError( "API backend does not support changing the port name.") if self._port is None: raise InvalidUseError("No port currently opened.") self.baseptr().setPortName(_to_bytes(name)) def set_error_callback(self, func, data=None): """Register a callback function for errors. The callback function is called when an error occurs and must take three arguments. The first argument is a member of enum ``RtMidiError::Type``, represented by one of the ``ERRORTYPE_*`` constants. The second argument is an error message. The third argument is the value of the ``data`` argument passed to this function when the callback is registered. .. note:: A default error handler function is registered on new instances of ``MidiIn`` and ``MidiOut``, which turns errors reported by the C++ layer into custom exceptions derived from ``RtMidiError``. If you replace this default error handler, be aware that the exception handling in your code probably needs to be adapted. Registering an error callback function replaces any previously registered error callback, including the above mentioned default error handler. """ self._error_callback = (func, data, self._decode_string) self.baseptr().setErrorCallback(&_cb_error_func, self._error_callback) def cancel_error_callback(self): """Remove the registered callback function for errors. This can be safely called even when no callback function has been registered and reinstates the default error handler. """ self.set_error_callback(_default_error_handler) cdef class MidiIn(MidiBase): """Midi input client interface. ``rtmidi.MidiIn(rtapi=API_UNSPECIFIED, name="RtMidi Client", queue_size_limit=1024)`` You can specify the low-level MIDI backend API to use via the ``rtapi`` keyword or the first positional argument, passing one of the module-level ``API_*`` constants. You can get a list of compiled-in APIs with the module-level ``get_compiled_api`` function. If you pass ``API_UNSPECIFIED`` (the default), the first compiled-in API, which has any input ports available, will be used. You can optionally pass a name for the MIDI client with the ``name`` keyword or the second positional argument. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. The default name is ``"RtMidiIn Client"``. .. note:: With some backend APIs (e.g. ALSA), the client name is set by the first ``MidiIn`` *or* ``MidiOut`` created by your program and does not change unless you either use the ``set_client_name`` method, or until *all* ``MidiIn`` and ``MidiOut`` instances are deleted and then a new one is created. The ``queue_size_limit`` argument specifies the size of the internal ring buffer in which incoming MIDI events are placed until retrieved via the ``get_message`` method (i.e. when no callback function is registered). The default value is ``1024`` (overriding the default value ``100`` of the underlying C++ RtMidi library). Exceptions: ``SystemError`` Raised when the RtMidi backend initialization fails. The execption message should have more information on the cause of the error. ``TypeError`` Raised when an incompatible value type is passed for a parameter. """ cdef RtMidiIn *thisptr cdef object _callback cdef RtMidi* baseptr(self): return self.thisptr def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, unsigned int queue_size_limit=1024): """Create a new client instance for MIDI input. See the class docstring for a description of the constructor arguments. """ if name is None: name = "RtMidiIn Client" try: self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) except RuntimeError as exc: raise SystemError(str(exc), type=ERR_DRIVER_ERROR) self.set_error_callback(_default_error_handler) self._callback = None self._port = None self._deleted = False def get_current_api(self): """Return the low-level MIDI backend API used by this instance. Use this by comparing the returned value to the module-level ``API_*`` constants, e.g.:: midiin = rtmidi.MidiIn() if midiin.get_current_api() == rtmidi.API_UNIX_JACK: print("Using JACK API for MIDI input.") """ return self.thisptr.getCurrentApi() def __dealloc__(self): """De-allocate pointer to C++ class instance.""" if hasattr(self, "thisptr"): del self.thisptr def delete(self): """De-allocate pointer to C++ class instance. .. warning:: the instance **must not** be used anymore after calling this method, otherwise the program will crash with a segmentation fault! The reason this potentially dangerous method exists is that in some cases it is desirable to destroy the internal ``RtMidiIn`` C++ class instance with immediate effect, thereby closing the backend MIDI API client and all the ports it opened. By merely using ``del`` on the ``rtmidi.MidiIn`` Python instance, the destruction of the C++ instance may be delayed for an arbitrary amount of time, until the Python garbage collector cleans up the instance. """ if not self._deleted: del self.thisptr self._deleted = True @property def is_deleted(self): return self._deleted def cancel_callback(self): """Remove the registered callback function for MIDI input. This can be safely called even when no callback function has been registered. """ if self._callback: self.thisptr.cancelCallback() self._callback = None def close_port(self): self.cancel_callback() MidiBase.close_port(self) close_port.__doc__ == MidiBase.close_port.__doc__ def get_message(self): """Poll for MIDI input. Checks whether a MIDI event is available in the input buffer and returns a two-element tuple with the MIDI message and a delta time. The MIDI message is a list of integers representing the data bytes of the message, the delta time is a float representing the time in seconds elapsed since the reception of the previous MIDI event. The function does not block. When no MIDI message is available, it returns ``None``. """ cdef vector[unsigned char] msg_v cdef double delta_time = self.thisptr.getMessage(&msg_v) if not msg_v.empty(): message = [msg_v.at(i) for i in range(msg_v.size())] return (message, delta_time) def ignore_types(self, sysex=True, timing=True, active_sense=True): """Enable/Disable input filtering of certain types of MIDI events. By default System Exclusive (aka sysex), MIDI Clock and Active Sensing messages are filtered from the MIDI input and never reach your code, because they can fill up input buffers very quickly. To receive them, you can selectively disable the filtering of these event types. To enable reception - i.e. turn off the default filtering - of sysex messages, pass ``sysex = False``. To enable reception of MIDI Clock, pass ``timing = False``. To enable reception of Active Sensing, pass ``active_sense = False``. These arguments can of course be combined in one call, and they all default to ``True``. If you enable reception of any of these event types, be sure to either use an input callback function, which returns quickly or poll for MIDI input often. Otherwise you might lose MIDI input because the input buffer overflows. **Windows note:** the Windows Multi Media API uses fixed size buffers for the reception of sysex messages, whose number and size is set at compile time. Sysex messages longer than the buffer size can not be received properly when using the Windows Multi Media API. The default distribution of python-rtmidi sets the number of sysex buffers to four and the size of each to 8192 bytes. To change these values, edit the ``RT_SYSEX_BUFFER_COUNT`` and ``RT_SYSEX_BUFFER_SIZE`` preprocessor defines in ``RtMidi.cpp`` and recompile. """ self.thisptr.ignoreTypes(sysex, timing, active_sense) def set_callback(self, func, data=None): """Register a callback function for MIDI input. The callback function is called whenever a MIDI message is received and must take two arguments. The first argument is a two-element tuple with the MIDI message and a delta time, like the one returned by the ``get_message`` method. The second argument is value of the ``data`` argument passed to ``set_callback`` when the callback is registered. The value of ``data`` can be any Python object. It can be used inside the callback function to access data that would not be in scope otherwise. Registering a callback function replaces any previously registered callback. The callback function is safely removed when the input port is closed or the ``MidiIn`` instance is deleted. """ if self._callback: self.cancel_callback() self._callback = (func, data) self.thisptr.setCallback(&_cb_func, self._callback) cdef class MidiOut(MidiBase): """Midi output client interface. ``rtmidi.MidiOut(rtapi=API_UNSPECIFIED, name="RtMidi Client")`` You can specify the low-level MIDI backend API to use via the ``rtapi`` keyword or the first positional argument, passing one of the module-level ``API_*`` constants. You can get a list of compiled-in APIs with the module-level ``get_compiled_api`` function. If you pass ``API_UNSPECIFIED`` (the default), the first compiled-in API, which has any input ports available, will be used. You can optionally pass a name for the MIDI client with the ``name`` keyword or the second positional argument. Names with non-ASCII characters in them have to be passed as unicode or UTF-8 encoded strings in Python 2. The default name is ``"RtMidiOut Client"``. .. note:: With some backend APIs (e.g. ALSA), the client name is set by the first ``MidiIn`` *or* ``MidiOut`` created by your program and does not change unless you either use the ``set_client_name`` method, or until *all* ``MidiIn`` and ``MidiOut`` instances are deleted and then a new one is created. Exceptions: ``SystemError`` Raised when the RtMidi backend initialization fails. The execption message should have more information on the cause of the error. ``TypeError`` Raised when an incompatible value type is passed for a parameter. """ cdef RtMidiOut *thisptr cdef RtMidi* baseptr(self): return self.thisptr def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): """Create a new client instance for MIDI output. See the class docstring for a description of the constructor arguments. """ if name is None: name = "RtMidiOut Client" try: self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) except RuntimeError as exc: raise SystemError(str(exc), type=ERR_DRIVER_ERROR) self.set_error_callback(_default_error_handler) self._port = None self._deleted = False def __dealloc__(self): """De-allocate pointer to C++ class instance.""" if hasattr(self, "thisptr"): del self.thisptr def delete(self): """De-allocate pointer to C++ class instance. .. warning:: the instance **must not** be used anymore after calling this method, otherwise the program will crash with a segmentation fault! The reason this potentially dangerous method exists is that in some cases it is desirable to destroy the internal ``RtMidiOut`` C++ class instance with immediate effect, thereby closing the backend MIDI API client and all the ports it opened. By merely using ``del`` on the ``rtmidi.MidiOut`` Python instance, the destruction of the C++ instance may be delayed for an arbitrary amount of time, until the Python garbage collector cleans up the instance. """ if not self._deleted: del self.thisptr self._deleted = True @property def is_deleted(self): return self._deleted def get_current_api(self): """Return the low-level MIDI backend API used by this instance. Use this by comparing the returned value to the module-level ``API_*`` constants, e.g.:: midiout = rtmidi.MidiOut() if midiout.get_current_api() == rtmidi.API_UNIX_JACK: print("Using JACK API for MIDI output.") """ return self.thisptr.getCurrentApi() def send_message(self, message): """Send a MIDI message to the output port. The message must be passed as an iterable yielding integers, each element representing one byte of the MIDI message. Normal MIDI messages have a length of one to three bytes, but you can also send system exclusive messages, which can be arbitrarily long, via this method. No check is made whether the passed data constitutes a valid MIDI message but if it is longer than 3 bytes, the value of the first byte must be a start-of-sysex status byte, i.e. 0xF0. Exceptions: ``ValueError`` Raised if ``message`` argument is empty or more than 3 bytes long and not a SysEx message. """ cdef vector[unsigned char] msg_v if not message: raise ValueError("'message' must not be empty.") if len(message) > 3 and message[0] != 0xF0: raise ValueError("'message' longer than 3 bytes but does not " "start with 0xF0.") for c in message: msg_v.push_back(c) self.thisptr.sendMessage(&msg_v) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1611767562.0 python-rtmidi-1.4.7/src/pyinit.h0000644000175000001440000000130200000000000015632 0ustar00chrisusers#include /* * This code initializes Python threads and GIL, because RtMidi calls Python * from native threads. * * See http://permalink.gmane.org/gmane.comp.python.cython.user/5837 * * *PyEval_InitThreads* is a no-op since Python.37 and deprecated since * Python 3.6. Now *Py_Initialize* initializes the GIL. * * The calls are in this separate C file instead of in the main .pyx file so * that we can use pre-compiler conditionals and don't get a compiler * deprecation warning on Python 3.9+ for including *PyEval_InitThreads*. */ void py_init() { #if PY_MAJOR_VERSION >= 3 and PY_MINOR_VERSION >= 7 Py_Initialize(); #else PyEval_InitThreads(); #endif }././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2524176 python-rtmidi-1.4.7/src/rtmidi/0000755000175000001440000000000000000000000015441 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1586886060.0 python-rtmidi-1.4.7/src/rtmidi/RtMidi.cpp0000644000175000001440000033256000000000000017346 0ustar00chrisusers/**********************************************************************/ /*! \class RtMidi \brief An abstract base class for realtime MIDI input/output. This class implements some common functionality for the realtime MIDI input/output subclasses RtMidiIn and RtMidiOut. RtMidi GitHub site: https://github.com/thestk/rtmidi RtMidi WWW site: http://www.music.mcgill.ca/~gary/rtmidi/ RtMidi: realtime MIDI i/o C++ classes Copyright (c) 2003-2019 Gary P. Scavone Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Any person wishing to distribute modifications to the Software is asked to send the modifications to the original developer so that they can be incorporated into the canonical version. This is, however, not a binding provision of this license. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**********************************************************************/ #include "RtMidi.h" #include #if defined(__MACOSX_CORE__) #if TARGET_OS_IPHONE #define AudioGetCurrentHostTime CAHostTimeBase::GetCurrentTime #define AudioConvertHostTimeToNanos CAHostTimeBase::ConvertToNanos #endif #endif // Default for Windows is to add an identifier to the port names; this // flag can be defined (e.g. in your project file) to disable this behaviour. //#define RTMIDI_DO_NOT_ENSURE_UNIQUE_PORTNAMES // **************************************************************** // // // MidiInApi and MidiOutApi subclass prototypes. // // **************************************************************** // #if !defined(__LINUX_ALSA__) && !defined(__UNIX_JACK__) && !defined(__MACOSX_CORE__) && !defined(__WINDOWS_MM__) #define __RTMIDI_DUMMY__ #endif #if defined(__MACOSX_CORE__) class MidiInCore: public MidiInApi { public: MidiInCore( const std::string &clientName, unsigned int queueSizeLimit ); ~MidiInCore( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::MACOSX_CORE; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); protected: void initialize( const std::string& clientName ); }; class MidiOutCore: public MidiOutApi { public: MidiOutCore( const std::string &clientName ); ~MidiOutCore( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::MACOSX_CORE; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); void sendMessage( const unsigned char *message, size_t size ); protected: void initialize( const std::string& clientName ); }; #endif #if defined(__UNIX_JACK__) class MidiInJack: public MidiInApi { public: MidiInJack( const std::string &clientName, unsigned int queueSizeLimit ); ~MidiInJack( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::UNIX_JACK; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); protected: std::string clientName; void connect( void ); void initialize( const std::string& clientName ); }; class MidiOutJack: public MidiOutApi { public: MidiOutJack( const std::string &clientName ); ~MidiOutJack( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::UNIX_JACK; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); void sendMessage( const unsigned char *message, size_t size ); protected: std::string clientName; void connect( void ); void initialize( const std::string& clientName ); }; #endif #if defined(__LINUX_ALSA__) class MidiInAlsa: public MidiInApi { public: MidiInAlsa( const std::string &clientName, unsigned int queueSizeLimit ); ~MidiInAlsa( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::LINUX_ALSA; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); protected: void initialize( const std::string& clientName ); }; class MidiOutAlsa: public MidiOutApi { public: MidiOutAlsa( const std::string &clientName ); ~MidiOutAlsa( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::LINUX_ALSA; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); void sendMessage( const unsigned char *message, size_t size ); protected: void initialize( const std::string& clientName ); }; #endif #if defined(__WINDOWS_MM__) class MidiInWinMM: public MidiInApi { public: MidiInWinMM( const std::string &clientName, unsigned int queueSizeLimit ); ~MidiInWinMM( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::WINDOWS_MM; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); protected: void initialize( const std::string& clientName ); }; class MidiOutWinMM: public MidiOutApi { public: MidiOutWinMM( const std::string &clientName ); ~MidiOutWinMM( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::WINDOWS_MM; }; void openPort( unsigned int portNumber, const std::string &portName ); void openVirtualPort( const std::string &portName ); void closePort( void ); void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); unsigned int getPortCount( void ); std::string getPortName( unsigned int portNumber ); void sendMessage( const unsigned char *message, size_t size ); protected: void initialize( const std::string& clientName ); }; #endif #if defined(__RTMIDI_DUMMY__) class MidiInDummy: public MidiInApi { public: MidiInDummy( const std::string &/*clientName*/, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { errorString_ = "MidiInDummy: This class provides no functionality."; error( RtMidiError::WARNING, errorString_ ); } RtMidi::Api getCurrentApi( void ) { return RtMidi::RTMIDI_DUMMY; } void openPort( unsigned int /*portNumber*/, const std::string &/*portName*/ ) {} void openVirtualPort( const std::string &/*portName*/ ) {} void closePort( void ) {} void setClientName( const std::string &/*clientName*/ ) {}; void setPortName( const std::string &/*portName*/ ) {}; unsigned int getPortCount( void ) { return 0; } std::string getPortName( unsigned int /*portNumber*/ ) { return ""; } protected: void initialize( const std::string& /*clientName*/ ) {} }; class MidiOutDummy: public MidiOutApi { public: MidiOutDummy( const std::string &/*clientName*/ ) { errorString_ = "MidiOutDummy: This class provides no functionality."; error( RtMidiError::WARNING, errorString_ ); } RtMidi::Api getCurrentApi( void ) { return RtMidi::RTMIDI_DUMMY; } void openPort( unsigned int /*portNumber*/, const std::string &/*portName*/ ) {} void openVirtualPort( const std::string &/*portName*/ ) {} void closePort( void ) {} void setClientName( const std::string &/*clientName*/ ) {}; void setPortName( const std::string &/*portName*/ ) {}; unsigned int getPortCount( void ) { return 0; } std::string getPortName( unsigned int /*portNumber*/ ) { return ""; } void sendMessage( const unsigned char * /*message*/, size_t /*size*/ ) {} protected: void initialize( const std::string& /*clientName*/ ) {} }; #endif //*********************************************************************// // RtMidi Definitions //*********************************************************************// RtMidi :: RtMidi() : rtapi_(0) { } RtMidi :: ~RtMidi() { delete rtapi_; rtapi_ = 0; } std::string RtMidi :: getVersion( void ) throw() { return std::string( RTMIDI_VERSION ); } // Define API names and display names. // Must be in same order as API enum. extern "C" { const char* rtmidi_api_names[][2] = { { "unspecified" , "Unknown" }, { "core" , "CoreMidi" }, { "alsa" , "ALSA" }, { "jack" , "Jack" }, { "winmm" , "Windows MultiMedia" }, { "dummy" , "Dummy" }, }; const unsigned int rtmidi_num_api_names = sizeof(rtmidi_api_names)/sizeof(rtmidi_api_names[0]); // The order here will control the order of RtMidi's API search in // the constructor. extern "C" const RtMidi::Api rtmidi_compiled_apis[] = { #if defined(__MACOSX_CORE__) RtMidi::MACOSX_CORE, #endif #if defined(__LINUX_ALSA__) RtMidi::LINUX_ALSA, #endif #if defined(__UNIX_JACK__) RtMidi::UNIX_JACK, #endif #if defined(__WINDOWS_MM__) RtMidi::WINDOWS_MM, #endif #if defined(__RTMIDI_DUMMY__) RtMidi::RTMIDI_DUMMY, #endif RtMidi::UNSPECIFIED, }; extern "C" const unsigned int rtmidi_num_compiled_apis = sizeof(rtmidi_compiled_apis)/sizeof(rtmidi_compiled_apis[0])-1; } // This is a compile-time check that rtmidi_num_api_names == RtMidi::NUM_APIS. // If the build breaks here, check that they match. template class StaticAssert { private: StaticAssert() {} }; template<> class StaticAssert{ public: StaticAssert() {} }; class StaticAssertions { StaticAssertions() { StaticAssert(); }}; void RtMidi :: getCompiledApi( std::vector &apis ) throw() { apis = std::vector(rtmidi_compiled_apis, rtmidi_compiled_apis + rtmidi_num_compiled_apis); } std::string RtMidi :: getApiName( RtMidi::Api api ) { if (api < 0 || api >= RtMidi::NUM_APIS) return ""; return rtmidi_api_names[api][0]; } std::string RtMidi :: getApiDisplayName( RtMidi::Api api ) { if (api < 0 || api >= RtMidi::NUM_APIS) return "Unknown"; return rtmidi_api_names[api][1]; } RtMidi::Api RtMidi :: getCompiledApiByName( const std::string &name ) { unsigned int i=0; for (i = 0; i < rtmidi_num_compiled_apis; ++i) if (name == rtmidi_api_names[rtmidi_compiled_apis[i]][0]) return rtmidi_compiled_apis[i]; return RtMidi::UNSPECIFIED; } void RtMidi :: setClientName( const std::string &clientName ) { rtapi_->setClientName( clientName ); } void RtMidi :: setPortName( const std::string &portName ) { rtapi_->setPortName( portName ); } //*********************************************************************// // RtMidiIn Definitions //*********************************************************************// void RtMidiIn :: openMidiApi( RtMidi::Api api, const std::string &clientName, unsigned int queueSizeLimit ) { delete rtapi_; rtapi_ = 0; #if defined(__UNIX_JACK__) if ( api == UNIX_JACK ) rtapi_ = new MidiInJack( clientName, queueSizeLimit ); #endif #if defined(__LINUX_ALSA__) if ( api == LINUX_ALSA ) rtapi_ = new MidiInAlsa( clientName, queueSizeLimit ); #endif #if defined(__WINDOWS_MM__) if ( api == WINDOWS_MM ) rtapi_ = new MidiInWinMM( clientName, queueSizeLimit ); #endif #if defined(__MACOSX_CORE__) if ( api == MACOSX_CORE ) rtapi_ = new MidiInCore( clientName, queueSizeLimit ); #endif #if defined(__RTMIDI_DUMMY__) if ( api == RTMIDI_DUMMY ) rtapi_ = new MidiInDummy( clientName, queueSizeLimit ); #endif } RTMIDI_DLL_PUBLIC RtMidiIn :: RtMidiIn( RtMidi::Api api, const std::string &clientName, unsigned int queueSizeLimit ) : RtMidi() { if ( api != UNSPECIFIED ) { // Attempt to open the specified API. openMidiApi( api, clientName, queueSizeLimit ); if ( rtapi_ ) return; // No compiled support for specified API value. Issue a warning // and continue as if no API was specified. std::cerr << "\nRtMidiIn: no compiled support for specified API argument!\n\n" << std::endl; } // Iterate through the compiled APIs and return as soon as we find // one with at least one port or we reach the end of the list. std::vector< RtMidi::Api > apis; getCompiledApi( apis ); for ( unsigned int i=0; igetPortCount() ) break; } if ( rtapi_ ) return; // It should not be possible to get here because the preprocessor // definition __RTMIDI_DUMMY__ is automatically defined if no // API-specific definitions are passed to the compiler. But just in // case something weird happens, we'll throw an error. std::string errorText = "RtMidiIn: no compiled API support found ... critical error!!"; throw( RtMidiError( errorText, RtMidiError::UNSPECIFIED ) ); } RtMidiIn :: ~RtMidiIn() throw() { } //*********************************************************************// // RtMidiOut Definitions //*********************************************************************// void RtMidiOut :: openMidiApi( RtMidi::Api api, const std::string &clientName ) { delete rtapi_; rtapi_ = 0; #if defined(__UNIX_JACK__) if ( api == UNIX_JACK ) rtapi_ = new MidiOutJack( clientName ); #endif #if defined(__LINUX_ALSA__) if ( api == LINUX_ALSA ) rtapi_ = new MidiOutAlsa( clientName ); #endif #if defined(__WINDOWS_MM__) if ( api == WINDOWS_MM ) rtapi_ = new MidiOutWinMM( clientName ); #endif #if defined(__MACOSX_CORE__) if ( api == MACOSX_CORE ) rtapi_ = new MidiOutCore( clientName ); #endif #if defined(__RTMIDI_DUMMY__) if ( api == RTMIDI_DUMMY ) rtapi_ = new MidiOutDummy( clientName ); #endif } RTMIDI_DLL_PUBLIC RtMidiOut :: RtMidiOut( RtMidi::Api api, const std::string &clientName) { if ( api != UNSPECIFIED ) { // Attempt to open the specified API. openMidiApi( api, clientName ); if ( rtapi_ ) return; // No compiled support for specified API value. Issue a warning // and continue as if no API was specified. std::cerr << "\nRtMidiOut: no compiled support for specified API argument!\n\n" << std::endl; } // Iterate through the compiled APIs and return as soon as we find // one with at least one port or we reach the end of the list. std::vector< RtMidi::Api > apis; getCompiledApi( apis ); for ( unsigned int i=0; igetPortCount() ) break; } if ( rtapi_ ) return; // It should not be possible to get here because the preprocessor // definition __RTMIDI_DUMMY__ is automatically defined if no // API-specific definitions are passed to the compiler. But just in // case something weird happens, we'll thrown an error. std::string errorText = "RtMidiOut: no compiled API support found ... critical error!!"; throw( RtMidiError( errorText, RtMidiError::UNSPECIFIED ) ); } RtMidiOut :: ~RtMidiOut() throw() { } //*********************************************************************// // Common MidiApi Definitions //*********************************************************************// MidiApi :: MidiApi( void ) : apiData_( 0 ), connected_( false ), errorCallback_(0), firstErrorOccurred_(false), errorCallbackUserData_(0) { } MidiApi :: ~MidiApi( void ) { } void MidiApi :: setErrorCallback( RtMidiErrorCallback errorCallback, void *userData = 0 ) { errorCallback_ = errorCallback; errorCallbackUserData_ = userData; } void MidiApi :: error( RtMidiError::Type type, std::string errorString ) { if ( errorCallback_ ) { if ( firstErrorOccurred_ ) return; firstErrorOccurred_ = true; const std::string errorMessage = errorString; errorCallback_( type, errorMessage, errorCallbackUserData_ ); firstErrorOccurred_ = false; return; } if ( type == RtMidiError::WARNING ) { #if !defined(__RTMIDI_SILENCE_WARNINGS__) std::cerr << '\n' << errorString << "\n\n"; #endif } else if ( type == RtMidiError::DEBUG_WARNING ) { #if defined(__RTMIDI_DEBUG__) std::cerr << '\n' << errorString << "\n\n"; #endif } else { // std::cerr << '\n' << errorString << "\n\n"; throw RtMidiError( errorString, type ); } } //*********************************************************************// // Common MidiInApi Definitions //*********************************************************************// MidiInApi :: MidiInApi( unsigned int queueSizeLimit ) : MidiApi() { // Allocate the MIDI queue. inputData_.queue.ringSize = queueSizeLimit; if ( inputData_.queue.ringSize > 0 ) inputData_.queue.ring = new MidiMessage[ inputData_.queue.ringSize ]; } MidiInApi :: ~MidiInApi( void ) { // Delete the MIDI queue. if ( inputData_.queue.ringSize > 0 ) delete [] inputData_.queue.ring; } void MidiInApi :: setCallback( RtMidiIn::RtMidiCallback callback, void *userData ) { if ( inputData_.usingCallback ) { errorString_ = "MidiInApi::setCallback: a callback function is already set!"; error( RtMidiError::WARNING, errorString_ ); return; } if ( !callback ) { errorString_ = "RtMidiIn::setCallback: callback function value is invalid!"; error( RtMidiError::WARNING, errorString_ ); return; } inputData_.userCallback = callback; inputData_.userData = userData; inputData_.usingCallback = true; } void MidiInApi :: cancelCallback() { if ( !inputData_.usingCallback ) { errorString_ = "RtMidiIn::cancelCallback: no callback function was set!"; error( RtMidiError::WARNING, errorString_ ); return; } inputData_.userCallback = 0; inputData_.userData = 0; inputData_.usingCallback = false; } void MidiInApi :: ignoreTypes( bool midiSysex, bool midiTime, bool midiSense ) { inputData_.ignoreFlags = 0; if ( midiSysex ) inputData_.ignoreFlags = 0x01; if ( midiTime ) inputData_.ignoreFlags |= 0x02; if ( midiSense ) inputData_.ignoreFlags |= 0x04; } double MidiInApi :: getMessage( std::vector *message ) { message->clear(); if ( inputData_.usingCallback ) { errorString_ = "RtMidiIn::getNextMessage: a user callback is currently set for this port."; error( RtMidiError::WARNING, errorString_ ); return 0.0; } double timeStamp; if ( !inputData_.queue.pop( message, &timeStamp ) ) return 0.0; return timeStamp; } unsigned int MidiInApi::MidiQueue::size( unsigned int *__back, unsigned int *__front ) { // Access back/front members exactly once and make stack copies for // size calculation unsigned int _back = back, _front = front, _size; if ( _back >= _front ) _size = _back - _front; else _size = ringSize - _front + _back; // Return copies of back/front so no new and unsynchronized accesses // to member variables are needed. if ( __back ) *__back = _back; if ( __front ) *__front = _front; return _size; } // As long as we haven't reached our queue size limit, push the message. bool MidiInApi::MidiQueue::push( const MidiInApi::MidiMessage& msg ) { // Local stack copies of front/back unsigned int _back, _front, _size; // Get back/front indexes exactly once and calculate current size _size = size( &_back, &_front ); if ( _size < ringSize-1 ) { ring[_back] = msg; back = (back+1)%ringSize; return true; } return false; } bool MidiInApi::MidiQueue::pop( std::vector *msg, double* timeStamp ) { // Local stack copies of front/back unsigned int _back, _front, _size; // Get back/front indexes exactly once and calculate current size _size = size( &_back, &_front ); if ( _size == 0 ) return false; // Copy queued message to the vector pointer argument and then "pop" it. msg->assign( ring[_front].bytes.begin(), ring[_front].bytes.end() ); *timeStamp = ring[_front].timeStamp; // Update front front = (front+1)%ringSize; return true; } //*********************************************************************// // Common MidiOutApi Definitions //*********************************************************************// MidiOutApi :: MidiOutApi( void ) : MidiApi() { } MidiOutApi :: ~MidiOutApi( void ) { } // *************************************************** // // // OS/API-specific methods. // // *************************************************** // #if defined(__MACOSX_CORE__) // The CoreMIDI API is based on the use of a callback function for // MIDI input. We convert the system specific time stamps to delta // time values. // OS-X CoreMIDI header files. #include #include #include // A structure to hold variables related to the CoreMIDI API // implementation. struct CoreMidiData { MIDIClientRef client; MIDIPortRef port; MIDIEndpointRef endpoint; MIDIEndpointRef destinationId; unsigned long long lastTime; MIDISysexSendRequest sysexreq; }; //*********************************************************************// // API: OS-X // Class Definitions: MidiInCore //*********************************************************************// static void midiInputCallback( const MIDIPacketList *list, void *procRef, void */*srcRef*/ ) { MidiInApi::RtMidiInData *data = static_cast (procRef); CoreMidiData *apiData = static_cast (data->apiData); unsigned char status; unsigned short nBytes, iByte, size; unsigned long long time; bool& continueSysex = data->continueSysex; MidiInApi::MidiMessage& message = data->message; const MIDIPacket *packet = &list->packet[0]; for ( unsigned int i=0; inumPackets; ++i ) { // My interpretation of the CoreMIDI documentation: all message // types, except sysex, are complete within a packet and there may // be several of them in a single packet. Sysex messages can be // broken across multiple packets and PacketLists but are bundled // alone within each packet (these packets do not contain other // message types). If sysex messages are split across multiple // MIDIPacketLists, they must be handled by multiple calls to this // function. nBytes = packet->length; if ( nBytes == 0 ) { packet = MIDIPacketNext( packet ); continue; } // Calculate time stamp. if ( data->firstMessage ) { message.timeStamp = 0.0; data->firstMessage = false; } else { time = packet->timeStamp; if ( time == 0 ) { // this happens when receiving asynchronous sysex messages time = AudioGetCurrentHostTime(); } time -= apiData->lastTime; time = AudioConvertHostTimeToNanos( time ); if ( !continueSysex ) message.timeStamp = time * 0.000000001; } // Track whether any non-filtered messages were found in this // packet for timestamp calculation bool foundNonFiltered = false; iByte = 0; if ( continueSysex ) { // We have a continuing, segmented sysex message. if ( !( data->ignoreFlags & 0x01 ) ) { // If we're not ignoring sysex messages, copy the entire packet. for ( unsigned int j=0; jdata[j] ); } continueSysex = packet->data[nBytes-1] != 0xF7; if ( !( data->ignoreFlags & 0x01 ) && !continueSysex ) { // If not a continuing sysex message, invoke the user callback function or queue the message. if ( data->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback; callback( message.timeStamp, &message.bytes, data->userData ); } else { // As long as we haven't reached our queue size limit, push the message. if ( !data->queue.push( message ) ) std::cerr << "\nMidiInCore: message queue limit reached!!\n\n"; } message.bytes.clear(); } } else { while ( iByte < nBytes ) { size = 0; // We are expecting that the next byte in the packet is a status byte. status = packet->data[iByte]; if ( !(status & 0x80) ) break; // Determine the number of bytes in the MIDI message. if ( status < 0xC0 ) size = 3; else if ( status < 0xE0 ) size = 2; else if ( status < 0xF0 ) size = 3; else if ( status == 0xF0 ) { // A MIDI sysex if ( data->ignoreFlags & 0x01 ) { size = 0; iByte = nBytes; } else size = nBytes - iByte; continueSysex = packet->data[nBytes-1] != 0xF7; } else if ( status == 0xF1 ) { // A MIDI time code message if ( data->ignoreFlags & 0x02 ) { size = 0; iByte += 2; } else size = 2; } else if ( status == 0xF2 ) size = 3; else if ( status == 0xF3 ) size = 2; else if ( status == 0xF8 && ( data->ignoreFlags & 0x02 ) ) { // A MIDI timing tick message and we're ignoring it. size = 0; iByte += 1; } else if ( status == 0xFE && ( data->ignoreFlags & 0x04 ) ) { // A MIDI active sensing message and we're ignoring it. size = 0; iByte += 1; } else size = 1; // Copy the MIDI data to our vector. if ( size ) { foundNonFiltered = true; message.bytes.assign( &packet->data[iByte], &packet->data[iByte+size] ); if ( !continueSysex ) { // If not a continuing sysex message, invoke the user callback function or queue the message. if ( data->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback; callback( message.timeStamp, &message.bytes, data->userData ); } else { // As long as we haven't reached our queue size limit, push the message. if ( !data->queue.push( message ) ) std::cerr << "\nMidiInCore: message queue limit reached!!\n\n"; } message.bytes.clear(); } iByte += size; } } } // Save the time of the last non-filtered message if ( foundNonFiltered ) { apiData->lastTime = packet->timeStamp; if ( apiData->lastTime == 0 ) { // this happens when receiving asynchronous sysex messages apiData->lastTime = AudioGetCurrentHostTime(); } } packet = MIDIPacketNext(packet); } } MidiInCore :: MidiInCore( const std::string &clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { MidiInCore::initialize( clientName ); } MidiInCore :: ~MidiInCore( void ) { // Close a connection if it exists. MidiInCore::closePort(); // Cleanup. CoreMidiData *data = static_cast (apiData_); MIDIClientDispose( data->client ); if ( data->endpoint ) MIDIEndpointDispose( data->endpoint ); delete data; } void MidiInCore :: initialize( const std::string& clientName ) { // Set up our client. MIDIClientRef client; CFStringRef name = CFStringCreateWithCString( NULL, clientName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDIClientCreate(name, NULL, NULL, &client ); if ( result != noErr ) { std::ostringstream ost; ost << "MidiInCore::initialize: error creating OS-X MIDI client object (" << result << ")."; errorString_ = ost.str(); error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific connection information. CoreMidiData *data = (CoreMidiData *) new CoreMidiData; data->client = client; data->endpoint = 0; apiData_ = (void *) data; inputData_.apiData = (void *) data; CFRelease( name ); } void MidiInCore :: openPort( unsigned int portNumber, const std::string &portName ) { if ( connected_ ) { errorString_ = "MidiInCore::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0, false ); unsigned int nSrc = MIDIGetNumberOfSources(); if ( nSrc < 1 ) { errorString_ = "MidiInCore::openPort: no MIDI input sources found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } if ( portNumber >= nSrc ) { std::ostringstream ost; ost << "MidiInCore::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } MIDIPortRef port; CoreMidiData *data = static_cast (apiData_); CFStringRef portNameRef = CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDIInputPortCreate( data->client, portNameRef, midiInputCallback, (void *)&inputData_, &port ); CFRelease( portNameRef ); if ( result != noErr ) { MIDIClientDispose( data->client ); errorString_ = "MidiInCore::openPort: error creating OS-X MIDI input port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Get the desired input source identifier. MIDIEndpointRef endpoint = MIDIGetSource( portNumber ); if ( endpoint == 0 ) { MIDIPortDispose( port ); MIDIClientDispose( data->client ); errorString_ = "MidiInCore::openPort: error getting MIDI input source reference."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Make the connection. result = MIDIPortConnectSource( port, endpoint, NULL ); if ( result != noErr ) { MIDIPortDispose( port ); MIDIClientDispose( data->client ); errorString_ = "MidiInCore::openPort: error connecting OS-X MIDI input port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific port information. data->port = port; connected_ = true; } void MidiInCore :: openVirtualPort( const std::string &portName ) { CoreMidiData *data = static_cast (apiData_); // Create a virtual MIDI input destination. MIDIEndpointRef endpoint; CFStringRef portNameRef = CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDIDestinationCreate( data->client, portNameRef, midiInputCallback, (void *)&inputData_, &endpoint ); CFRelease( portNameRef ); if ( result != noErr ) { errorString_ = "MidiInCore::openVirtualPort: error creating virtual OS-X MIDI destination."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific connection information. data->endpoint = endpoint; } void MidiInCore :: closePort( void ) { CoreMidiData *data = static_cast (apiData_); if ( data->endpoint ) { MIDIEndpointDispose( data->endpoint ); data->endpoint = 0; } if ( data->port ) { MIDIPortDispose( data->port ); data->port = 0; } connected_ = false; } void MidiInCore :: setClientName ( const std::string& ) { errorString_ = "MidiInCore::setClientName: this function is not implemented for the MACOSX_CORE API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiInCore :: setPortName ( const std::string& ) { errorString_ = "MidiInCore::setPortName: this function is not implemented for the MACOSX_CORE API!"; error( RtMidiError::WARNING, errorString_ ); } unsigned int MidiInCore :: getPortCount() { CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0, false ); return MIDIGetNumberOfSources(); } // This function was submitted by Douglas Casey Tucker and apparently // derived largely from PortMidi. CFStringRef EndpointName( MIDIEndpointRef endpoint, bool isExternal ) { CFMutableStringRef result = CFStringCreateMutable( NULL, 0 ); CFStringRef str; // Begin with the endpoint's name. str = NULL; MIDIObjectGetStringProperty( endpoint, kMIDIPropertyName, &str ); if ( str != NULL ) { CFStringAppend( result, str ); CFRelease( str ); } MIDIEntityRef entity = 0; MIDIEndpointGetEntity( endpoint, &entity ); if ( entity == 0 ) // probably virtual return result; if ( CFStringGetLength( result ) == 0 ) { // endpoint name has zero length -- try the entity str = NULL; MIDIObjectGetStringProperty( entity, kMIDIPropertyName, &str ); if ( str != NULL ) { CFStringAppend( result, str ); CFRelease( str ); } } // now consider the device's name MIDIDeviceRef device = 0; MIDIEntityGetDevice( entity, &device ); if ( device == 0 ) return result; str = NULL; MIDIObjectGetStringProperty( device, kMIDIPropertyName, &str ); if ( CFStringGetLength( result ) == 0 ) { CFRelease( result ); return str; } if ( str != NULL ) { // if an external device has only one entity, throw away // the endpoint name and just use the device name if ( isExternal && MIDIDeviceGetNumberOfEntities( device ) < 2 ) { CFRelease( result ); return str; } else { if ( CFStringGetLength( str ) == 0 ) { CFRelease( str ); return result; } // does the entity name already start with the device name? // (some drivers do this though they shouldn't) // if so, do not prepend if ( CFStringCompareWithOptions( result, /* endpoint name */ str /* device name */, CFRangeMake(0, CFStringGetLength( str ) ), 0 ) != kCFCompareEqualTo ) { // prepend the device name to the entity name if ( CFStringGetLength( result ) > 0 ) CFStringInsert( result, 0, CFSTR(" ") ); CFStringInsert( result, 0, str ); } CFRelease( str ); } } return result; } // This function was submitted by Douglas Casey Tucker and apparently // derived largely from PortMidi. static CFStringRef ConnectedEndpointName( MIDIEndpointRef endpoint ) { CFMutableStringRef result = CFStringCreateMutable( NULL, 0 ); CFStringRef str; OSStatus err; int i; // Does the endpoint have connections? CFDataRef connections = NULL; int nConnected = 0; bool anyStrings = false; err = MIDIObjectGetDataProperty( endpoint, kMIDIPropertyConnectionUniqueID, &connections ); if ( connections != NULL ) { // It has connections, follow them // Concatenate the names of all connected devices nConnected = CFDataGetLength( connections ) / sizeof(MIDIUniqueID); if ( nConnected ) { const SInt32 *pid = (const SInt32 *)(CFDataGetBytePtr(connections)); for ( i=0; i= MIDIGetNumberOfSources() ) { std::ostringstream ost; ost << "MidiInCore::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::WARNING, errorString_ ); return stringName; } portRef = MIDIGetSource( portNumber ); nameRef = ConnectedEndpointName( portRef ); CFStringGetCString( nameRef, name, sizeof(name), kCFStringEncodingUTF8 ); CFRelease( nameRef ); return stringName = name; } //*********************************************************************// // API: OS-X // Class Definitions: MidiOutCore //*********************************************************************// MidiOutCore :: MidiOutCore( const std::string &clientName ) : MidiOutApi() { MidiOutCore::initialize( clientName ); } MidiOutCore :: ~MidiOutCore( void ) { // Close a connection if it exists. MidiOutCore::closePort(); // Cleanup. CoreMidiData *data = static_cast (apiData_); MIDIClientDispose( data->client ); if ( data->endpoint ) MIDIEndpointDispose( data->endpoint ); delete data; } void MidiOutCore :: initialize( const std::string& clientName ) { // Set up our client. MIDIClientRef client; CFStringRef name = CFStringCreateWithCString( NULL, clientName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDIClientCreate(name, NULL, NULL, &client ); if ( result != noErr ) { std::ostringstream ost; ost << "MidiInCore::initialize: error creating OS-X MIDI client object (" << result << ")."; errorString_ = ost.str(); error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific connection information. CoreMidiData *data = (CoreMidiData *) new CoreMidiData; data->client = client; data->endpoint = 0; apiData_ = (void *) data; CFRelease( name ); } unsigned int MidiOutCore :: getPortCount() { CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0, false ); return MIDIGetNumberOfDestinations(); } std::string MidiOutCore :: getPortName( unsigned int portNumber ) { CFStringRef nameRef; MIDIEndpointRef portRef; char name[128]; std::string stringName; CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0, false ); if ( portNumber >= MIDIGetNumberOfDestinations() ) { std::ostringstream ost; ost << "MidiOutCore::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::WARNING, errorString_ ); return stringName; } portRef = MIDIGetDestination( portNumber ); nameRef = ConnectedEndpointName(portRef); CFStringGetCString( nameRef, name, sizeof(name), kCFStringEncodingUTF8 ); CFRelease( nameRef ); return stringName = name; } void MidiOutCore :: openPort( unsigned int portNumber, const std::string &portName ) { if ( connected_ ) { errorString_ = "MidiOutCore::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0, false ); unsigned int nDest = MIDIGetNumberOfDestinations(); if (nDest < 1) { errorString_ = "MidiOutCore::openPort: no MIDI output destinations found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } if ( portNumber >= nDest ) { std::ostringstream ost; ost << "MidiOutCore::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } MIDIPortRef port; CoreMidiData *data = static_cast (apiData_); CFStringRef portNameRef = CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDIOutputPortCreate( data->client, portNameRef, &port ); CFRelease( portNameRef ); if ( result != noErr ) { MIDIClientDispose( data->client ); errorString_ = "MidiOutCore::openPort: error creating OS-X MIDI output port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Get the desired output port identifier. MIDIEndpointRef destination = MIDIGetDestination( portNumber ); if ( destination == 0 ) { MIDIPortDispose( port ); MIDIClientDispose( data->client ); errorString_ = "MidiOutCore::openPort: error getting MIDI output destination reference."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific connection information. data->port = port; data->destinationId = destination; connected_ = true; } void MidiOutCore :: closePort( void ) { CoreMidiData *data = static_cast (apiData_); if ( data->endpoint ) { MIDIEndpointDispose( data->endpoint ); data->endpoint = 0; } if ( data->port ) { MIDIPortDispose( data->port ); data->port = 0; } connected_ = false; } void MidiOutCore :: setClientName ( const std::string& ) { errorString_ = "MidiOutCore::setClientName: this function is not implemented for the MACOSX_CORE API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutCore :: setPortName ( const std::string& ) { errorString_ = "MidiOutCore::setPortName: this function is not implemented for the MACOSX_CORE API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutCore :: openVirtualPort( const std::string &portName ) { CoreMidiData *data = static_cast (apiData_); if ( data->endpoint ) { errorString_ = "MidiOutCore::openVirtualPort: a virtual output port already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } // Create a virtual MIDI output source. MIDIEndpointRef endpoint; CFStringRef portNameRef = CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ); OSStatus result = MIDISourceCreate( data->client, portNameRef, &endpoint ); CFRelease( portNameRef ); if ( result != noErr ) { errorString_ = "MidiOutCore::initialize: error creating OS-X virtual MIDI source."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Save our api-specific connection information. data->endpoint = endpoint; } void MidiOutCore :: sendMessage( const unsigned char *message, size_t size ) { // We use the MIDISendSysex() function to asynchronously send sysex // messages. Otherwise, we use a single CoreMidi MIDIPacket. unsigned int nBytes = static_cast (size); if ( nBytes == 0 ) { errorString_ = "MidiOutCore::sendMessage: no data in message argument!"; error( RtMidiError::WARNING, errorString_ ); return; } MIDITimeStamp timeStamp = AudioGetCurrentHostTime(); CoreMidiData *data = static_cast (apiData_); OSStatus result; if ( message[0] != 0xF0 && nBytes > 3 ) { errorString_ = "MidiOutCore::sendMessage: message format problem ... not sysex but > 3 bytes?"; error( RtMidiError::WARNING, errorString_ ); return; } Byte buffer[nBytes+(sizeof( MIDIPacketList ))]; ByteCount listSize = sizeof( buffer ); MIDIPacketList *packetList = (MIDIPacketList*)buffer; MIDIPacket *packet = MIDIPacketListInit( packetList ); ByteCount remainingBytes = nBytes; while ( remainingBytes && packet ) { ByteCount bytesForPacket = remainingBytes > 65535 ? 65535 : remainingBytes; // 65535 = maximum size of a MIDIPacket const Byte* dataStartPtr = (const Byte *) &message[nBytes - remainingBytes]; packet = MIDIPacketListAdd( packetList, listSize, packet, timeStamp, bytesForPacket, dataStartPtr ); remainingBytes -= bytesForPacket; } if ( !packet ) { errorString_ = "MidiOutCore::sendMessage: could not allocate packet list"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Send to any destinations that may have connected to us. if ( data->endpoint ) { result = MIDIReceived( data->endpoint, packetList ); if ( result != noErr ) { errorString_ = "MidiOutCore::sendMessage: error sending MIDI to virtual destinations."; error( RtMidiError::WARNING, errorString_ ); } } // And send to an explicit destination port if we're connected. if ( connected_ ) { result = MIDISend( data->port, data->destinationId, packetList ); if ( result != noErr ) { errorString_ = "MidiOutCore::sendMessage: error sending MIDI message to port."; error( RtMidiError::WARNING, errorString_ ); } } } #endif // __MACOSX_CORE__ //*********************************************************************// // API: LINUX ALSA SEQUENCER //*********************************************************************// // API information found at: // - http://www.alsa-project.org/documentation.php#Library #if defined(__LINUX_ALSA__) // The ALSA Sequencer API is based on the use of a callback function for // MIDI input. // // Thanks to Pedro Lopez-Cabanillas for help with the ALSA sequencer // time stamps and other assorted fixes!!! // If you don't need timestamping for incoming MIDI events, define the // preprocessor definition AVOID_TIMESTAMPING to save resources // associated with the ALSA sequencer queues. #include #include // ALSA header file. #include // A structure to hold variables related to the ALSA API // implementation. struct AlsaMidiData { snd_seq_t *seq; unsigned int portNum; int vport; snd_seq_port_subscribe_t *subscription; snd_midi_event_t *coder; unsigned int bufferSize; unsigned char *buffer; pthread_t thread; pthread_t dummy_thread_id; snd_seq_real_time_t lastTime; int queue_id; // an input queue is needed to get timestamped events int trigger_fds[2]; }; #define PORT_TYPE( pinfo, bits ) ((snd_seq_port_info_get_capability(pinfo) & (bits)) == (bits)) //*********************************************************************// // API: LINUX ALSA // Class Definitions: MidiInAlsa //*********************************************************************// static void *alsaMidiHandler( void *ptr ) { MidiInApi::RtMidiInData *data = static_cast (ptr); AlsaMidiData *apiData = static_cast (data->apiData); long nBytes; double time; bool continueSysex = false; bool doDecode = false; MidiInApi::MidiMessage message; int poll_fd_count; struct pollfd *poll_fds; snd_seq_event_t *ev; int result; apiData->bufferSize = 32; result = snd_midi_event_new( 0, &apiData->coder ); if ( result < 0 ) { data->doInput = false; std::cerr << "\nMidiInAlsa::alsaMidiHandler: error initializing MIDI event parser!\n\n"; return 0; } unsigned char *buffer = (unsigned char *) malloc( apiData->bufferSize ); if ( buffer == NULL ) { data->doInput = false; snd_midi_event_free( apiData->coder ); apiData->coder = 0; std::cerr << "\nMidiInAlsa::alsaMidiHandler: error initializing buffer memory!\n\n"; return 0; } snd_midi_event_init( apiData->coder ); snd_midi_event_no_status( apiData->coder, 1 ); // suppress running status messages poll_fd_count = snd_seq_poll_descriptors_count( apiData->seq, POLLIN ) + 1; poll_fds = (struct pollfd*)alloca( poll_fd_count * sizeof( struct pollfd )); snd_seq_poll_descriptors( apiData->seq, poll_fds + 1, poll_fd_count - 1, POLLIN ); poll_fds[0].fd = apiData->trigger_fds[0]; poll_fds[0].events = POLLIN; while ( data->doInput ) { if ( snd_seq_event_input_pending( apiData->seq, 1 ) == 0 ) { // No data pending if ( poll( poll_fds, poll_fd_count, -1) >= 0 ) { if ( poll_fds[0].revents & POLLIN ) { bool dummy; int res = read( poll_fds[0].fd, &dummy, sizeof(dummy) ); (void) res; } } continue; } // If here, there should be data. result = snd_seq_event_input( apiData->seq, &ev ); if ( result == -ENOSPC ) { std::cerr << "\nMidiInAlsa::alsaMidiHandler: MIDI input buffer overrun!\n\n"; continue; } else if ( result <= 0 ) { std::cerr << "\nMidiInAlsa::alsaMidiHandler: unknown MIDI input error!\n"; perror("System reports"); continue; } // This is a bit weird, but we now have to decode an ALSA MIDI // event (back) into MIDI bytes. We'll ignore non-MIDI types. if ( !continueSysex ) message.bytes.clear(); doDecode = false; switch ( ev->type ) { case SND_SEQ_EVENT_PORT_SUBSCRIBED: #if defined(__RTMIDI_DEBUG__) std::cout << "MidiInAlsa::alsaMidiHandler: port connection made!\n"; #endif break; case SND_SEQ_EVENT_PORT_UNSUBSCRIBED: #if defined(__RTMIDI_DEBUG__) std::cerr << "MidiInAlsa::alsaMidiHandler: port connection has closed!\n"; std::cout << "sender = " << (int) ev->data.connect.sender.client << ":" << (int) ev->data.connect.sender.port << ", dest = " << (int) ev->data.connect.dest.client << ":" << (int) ev->data.connect.dest.port << std::endl; #endif break; case SND_SEQ_EVENT_QFRAME: // MIDI time code if ( !( data->ignoreFlags & 0x02 ) ) doDecode = true; break; case SND_SEQ_EVENT_TICK: // 0xF9 ... MIDI timing tick if ( !( data->ignoreFlags & 0x02 ) ) doDecode = true; break; case SND_SEQ_EVENT_CLOCK: // 0xF8 ... MIDI timing (clock) tick if ( !( data->ignoreFlags & 0x02 ) ) doDecode = true; break; case SND_SEQ_EVENT_SENSING: // Active sensing if ( !( data->ignoreFlags & 0x04 ) ) doDecode = true; break; case SND_SEQ_EVENT_SYSEX: if ( (data->ignoreFlags & 0x01) ) break; if ( ev->data.ext.len > apiData->bufferSize ) { apiData->bufferSize = ev->data.ext.len; free( buffer ); buffer = (unsigned char *) malloc( apiData->bufferSize ); if ( buffer == NULL ) { data->doInput = false; std::cerr << "\nMidiInAlsa::alsaMidiHandler: error resizing buffer memory!\n\n"; break; } } doDecode = true; break; default: doDecode = true; } if ( doDecode ) { nBytes = snd_midi_event_decode( apiData->coder, buffer, apiData->bufferSize, ev ); if ( nBytes > 0 ) { // The ALSA sequencer has a maximum buffer size for MIDI sysex // events of 256 bytes. If a device sends sysex messages larger // than this, they are segmented into 256 byte chunks. So, // we'll watch for this and concatenate sysex chunks into a // single sysex message if necessary. if ( !continueSysex ) message.bytes.assign( buffer, &buffer[nBytes] ); else message.bytes.insert( message.bytes.end(), buffer, &buffer[nBytes] ); continueSysex = ( ( ev->type == SND_SEQ_EVENT_SYSEX ) && ( message.bytes.back() != 0xF7 ) ); if ( !continueSysex ) { // Calculate the time stamp: message.timeStamp = 0.0; // Method 1: Use the system time. //(void)gettimeofday(&tv, (struct timezone *)NULL); //time = (tv.tv_sec * 1000000) + tv.tv_usec; // Method 2: Use the ALSA sequencer event time data. // (thanks to Pedro Lopez-Cabanillas!). // Using method from: // https://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html // Perform the carry for the later subtraction by updating y. // Temp var y is timespec because computation requires signed types, // while snd_seq_real_time_t has unsigned types. snd_seq_real_time_t &x( ev->time.time ); struct timespec y; y.tv_nsec = apiData->lastTime.tv_nsec; y.tv_sec = apiData->lastTime.tv_sec; if ( x.tv_nsec < y.tv_nsec ) { int nsec = (y.tv_nsec - (int)x.tv_nsec) / 1000000000 + 1; y.tv_nsec -= 1000000000 * nsec; y.tv_sec += nsec; } if ( x.tv_nsec - y.tv_nsec > 1000000000 ) { int nsec = ((int)x.tv_nsec - y.tv_nsec) / 1000000000; y.tv_nsec += 1000000000 * nsec; y.tv_sec -= nsec; } // Compute the time difference. time = (int)x.tv_sec - y.tv_sec + ((int)x.tv_nsec - y.tv_nsec)*1e-9; apiData->lastTime = ev->time.time; if ( data->firstMessage == true ) data->firstMessage = false; else message.timeStamp = time; } else { #if defined(__RTMIDI_DEBUG__) std::cerr << "\nMidiInAlsa::alsaMidiHandler: event parsing error or not a MIDI event!\n\n"; #endif } } } snd_seq_free_event( ev ); if ( message.bytes.size() == 0 || continueSysex ) continue; if ( data->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback; callback( message.timeStamp, &message.bytes, data->userData ); } else { // As long as we haven't reached our queue size limit, push the message. if ( !data->queue.push( message ) ) std::cerr << "\nMidiInAlsa: message queue limit reached!!\n\n"; } } if ( buffer ) free( buffer ); snd_midi_event_free( apiData->coder ); apiData->coder = 0; apiData->thread = apiData->dummy_thread_id; return 0; } MidiInAlsa :: MidiInAlsa( const std::string &clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { MidiInAlsa::initialize( clientName ); } MidiInAlsa :: ~MidiInAlsa() { // Close a connection if it exists. MidiInAlsa::closePort(); // Shutdown the input thread. AlsaMidiData *data = static_cast (apiData_); if ( inputData_.doInput ) { inputData_.doInput = false; int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof( inputData_.doInput ) ); (void) res; if ( !pthread_equal(data->thread, data->dummy_thread_id) ) pthread_join( data->thread, NULL ); } // Cleanup. close ( data->trigger_fds[0] ); close ( data->trigger_fds[1] ); if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport ); #ifndef AVOID_TIMESTAMPING snd_seq_free_queue( data->seq, data->queue_id ); #endif snd_seq_close( data->seq ); delete data; } void MidiInAlsa :: initialize( const std::string& clientName ) { // Set up the ALSA sequencer client. snd_seq_t *seq; int result = snd_seq_open( &seq, "default", SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK ); if ( result < 0 ) { errorString_ = "MidiInAlsa::initialize: error creating ALSA sequencer client object."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Set client name. snd_seq_set_client_name( seq, clientName.c_str() ); // Save our api-specific connection information. AlsaMidiData *data = (AlsaMidiData *) new AlsaMidiData; data->seq = seq; data->portNum = -1; data->vport = -1; data->subscription = 0; data->dummy_thread_id = pthread_self(); data->thread = data->dummy_thread_id; data->trigger_fds[0] = -1; data->trigger_fds[1] = -1; apiData_ = (void *) data; inputData_.apiData = (void *) data; if ( pipe(data->trigger_fds) == -1 ) { errorString_ = "MidiInAlsa::initialize: error creating pipe objects."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Create the input queue #ifndef AVOID_TIMESTAMPING data->queue_id = snd_seq_alloc_named_queue( seq, "RtMidi Queue" ); // Set arbitrary tempo (mm=100) and resolution (240) snd_seq_queue_tempo_t *qtempo; snd_seq_queue_tempo_alloca( &qtempo ); snd_seq_queue_tempo_set_tempo( qtempo, 600000 ); snd_seq_queue_tempo_set_ppq( qtempo, 240 ); snd_seq_set_queue_tempo( data->seq, data->queue_id, qtempo ); snd_seq_drain_output( data->seq ); #endif } // This function is used to count or get the pinfo structure for a given port number. unsigned int portInfo( snd_seq_t *seq, snd_seq_port_info_t *pinfo, unsigned int type, int portNumber ) { snd_seq_client_info_t *cinfo; int client; int count = 0; snd_seq_client_info_alloca( &cinfo ); snd_seq_client_info_set_client( cinfo, -1 ); while ( snd_seq_query_next_client( seq, cinfo ) >= 0 ) { client = snd_seq_client_info_get_client( cinfo ); if ( client == 0 ) continue; // Reset query info snd_seq_port_info_set_client( pinfo, client ); snd_seq_port_info_set_port( pinfo, -1 ); while ( snd_seq_query_next_port( seq, pinfo ) >= 0 ) { unsigned int atyp = snd_seq_port_info_get_type( pinfo ); if ( ( ( atyp & SND_SEQ_PORT_TYPE_MIDI_GENERIC ) == 0 ) && ( ( atyp & SND_SEQ_PORT_TYPE_SYNTH ) == 0 ) && ( ( atyp & SND_SEQ_PORT_TYPE_APPLICATION ) == 0 ) ) continue; unsigned int caps = snd_seq_port_info_get_capability( pinfo ); if ( ( caps & type ) != type ) continue; if ( count == portNumber ) return 1; ++count; } } // If a negative portNumber was used, return the port count. if ( portNumber < 0 ) return count; return 0; } unsigned int MidiInAlsa :: getPortCount() { snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); AlsaMidiData *data = static_cast (apiData_); return portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, -1 ); } std::string MidiInAlsa :: getPortName( unsigned int portNumber ) { snd_seq_client_info_t *cinfo; snd_seq_port_info_t *pinfo; snd_seq_client_info_alloca( &cinfo ); snd_seq_port_info_alloca( &pinfo ); std::string stringName; AlsaMidiData *data = static_cast (apiData_); if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) ) { int cnum = snd_seq_port_info_get_client( pinfo ); snd_seq_get_any_client_info( data->seq, cnum, cinfo ); std::ostringstream os; os << snd_seq_client_info_get_name( cinfo ); os << ":"; os << snd_seq_port_info_get_name( pinfo ); os << " "; // These lines added to make sure devices are listed os << snd_seq_port_info_get_client( pinfo ); // with full portnames added to ensure individual device names os << ":"; os << snd_seq_port_info_get_port( pinfo ); stringName = os.str(); return stringName; } // If we get here, we didn't find a match. errorString_ = "MidiInAlsa::getPortName: error looking for port name!"; error( RtMidiError::WARNING, errorString_ ); return stringName; } void MidiInAlsa :: openPort( unsigned int portNumber, const std::string &portName ) { if ( connected_ ) { errorString_ = "MidiInAlsa::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } unsigned int nSrc = this->getPortCount(); if ( nSrc < 1 ) { errorString_ = "MidiInAlsa::openPort: no MIDI input sources found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } snd_seq_port_info_t *src_pinfo; snd_seq_port_info_alloca( &src_pinfo ); AlsaMidiData *data = static_cast (apiData_); if ( portInfo( data->seq, src_pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) == 0 ) { std::ostringstream ost; ost << "MidiInAlsa::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } snd_seq_addr_t sender, receiver; sender.client = snd_seq_port_info_get_client( src_pinfo ); sender.port = snd_seq_port_info_get_port( src_pinfo ); receiver.client = snd_seq_client_id( data->seq ); snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); if ( data->vport < 0 ) { snd_seq_port_info_set_client( pinfo, 0 ); snd_seq_port_info_set_port( pinfo, 0 ); snd_seq_port_info_set_capability( pinfo, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE ); snd_seq_port_info_set_type( pinfo, SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION ); snd_seq_port_info_set_midi_channels(pinfo, 16); #ifndef AVOID_TIMESTAMPING snd_seq_port_info_set_timestamping( pinfo, 1 ); snd_seq_port_info_set_timestamp_real( pinfo, 1 ); snd_seq_port_info_set_timestamp_queue( pinfo, data->queue_id ); #endif snd_seq_port_info_set_name( pinfo, portName.c_str() ); data->vport = snd_seq_create_port( data->seq, pinfo ); if ( data->vport < 0 ) { errorString_ = "MidiInAlsa::openPort: ALSA error creating input port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } data->vport = snd_seq_port_info_get_port( pinfo ); } receiver.port = data->vport; if ( !data->subscription ) { // Make subscription if ( snd_seq_port_subscribe_malloc( &data->subscription ) < 0 ) { errorString_ = "MidiInAlsa::openPort: ALSA error allocation port subscription."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } snd_seq_port_subscribe_set_sender( data->subscription, &sender ); snd_seq_port_subscribe_set_dest( data->subscription, &receiver ); if ( snd_seq_subscribe_port( data->seq, data->subscription ) ) { snd_seq_port_subscribe_free( data->subscription ); data->subscription = 0; errorString_ = "MidiInAlsa::openPort: ALSA error making port connection."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } } if ( inputData_.doInput == false ) { // Start the input queue #ifndef AVOID_TIMESTAMPING snd_seq_start_queue( data->seq, data->queue_id, NULL ); snd_seq_drain_output( data->seq ); #endif // Start our MIDI input thread. pthread_attr_t attr; pthread_attr_init( &attr ); pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); pthread_attr_setschedpolicy( &attr, SCHED_OTHER ); inputData_.doInput = true; int err = pthread_create( &data->thread, &attr, alsaMidiHandler, &inputData_ ); pthread_attr_destroy( &attr ); if ( err ) { snd_seq_unsubscribe_port( data->seq, data->subscription ); snd_seq_port_subscribe_free( data->subscription ); data->subscription = 0; inputData_.doInput = false; errorString_ = "MidiInAlsa::openPort: error starting MIDI input thread!"; error( RtMidiError::THREAD_ERROR, errorString_ ); return; } } connected_ = true; } void MidiInAlsa :: openVirtualPort( const std::string &portName ) { AlsaMidiData *data = static_cast (apiData_); if ( data->vport < 0 ) { snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); snd_seq_port_info_set_capability( pinfo, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE ); snd_seq_port_info_set_type( pinfo, SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION ); snd_seq_port_info_set_midi_channels( pinfo, 16 ); #ifndef AVOID_TIMESTAMPING snd_seq_port_info_set_timestamping( pinfo, 1 ); snd_seq_port_info_set_timestamp_real( pinfo, 1 ); snd_seq_port_info_set_timestamp_queue( pinfo, data->queue_id ); #endif snd_seq_port_info_set_name( pinfo, portName.c_str() ); data->vport = snd_seq_create_port( data->seq, pinfo ); if ( data->vport < 0 ) { errorString_ = "MidiInAlsa::openVirtualPort: ALSA error creating virtual port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } data->vport = snd_seq_port_info_get_port( pinfo ); } if ( inputData_.doInput == false ) { // Wait for old thread to stop, if still running if ( !pthread_equal( data->thread, data->dummy_thread_id ) ) pthread_join( data->thread, NULL ); // Start the input queue #ifndef AVOID_TIMESTAMPING snd_seq_start_queue( data->seq, data->queue_id, NULL ); snd_seq_drain_output( data->seq ); #endif // Start our MIDI input thread. pthread_attr_t attr; pthread_attr_init( &attr ); pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); pthread_attr_setschedpolicy( &attr, SCHED_OTHER ); inputData_.doInput = true; int err = pthread_create( &data->thread, &attr, alsaMidiHandler, &inputData_ ); pthread_attr_destroy( &attr ); if ( err ) { if ( data->subscription ) { snd_seq_unsubscribe_port( data->seq, data->subscription ); snd_seq_port_subscribe_free( data->subscription ); data->subscription = 0; } inputData_.doInput = false; errorString_ = "MidiInAlsa::openPort: error starting MIDI input thread!"; error( RtMidiError::THREAD_ERROR, errorString_ ); return; } } } void MidiInAlsa :: closePort( void ) { AlsaMidiData *data = static_cast (apiData_); if ( connected_ ) { if ( data->subscription ) { snd_seq_unsubscribe_port( data->seq, data->subscription ); snd_seq_port_subscribe_free( data->subscription ); data->subscription = 0; } // Stop the input queue #ifndef AVOID_TIMESTAMPING snd_seq_stop_queue( data->seq, data->queue_id, NULL ); snd_seq_drain_output( data->seq ); #endif connected_ = false; } // Stop thread to avoid triggering the callback, while the port is intended to be closed if ( inputData_.doInput ) { inputData_.doInput = false; int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof( inputData_.doInput ) ); (void) res; if ( !pthread_equal( data->thread, data->dummy_thread_id ) ) pthread_join( data->thread, NULL ); } } void MidiInAlsa :: setClientName( const std::string &clientName ) { AlsaMidiData *data = static_cast ( apiData_ ); snd_seq_set_client_name( data->seq, clientName.c_str() ); } void MidiInAlsa :: setPortName( const std::string &portName ) { AlsaMidiData *data = static_cast (apiData_); snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); snd_seq_get_port_info( data->seq, data->vport, pinfo ); snd_seq_port_info_set_name( pinfo, portName.c_str() ); snd_seq_set_port_info( data->seq, data->vport, pinfo ); } //*********************************************************************// // API: LINUX ALSA // Class Definitions: MidiOutAlsa //*********************************************************************// MidiOutAlsa :: MidiOutAlsa( const std::string &clientName ) : MidiOutApi() { MidiOutAlsa::initialize( clientName ); } MidiOutAlsa :: ~MidiOutAlsa() { // Close a connection if it exists. MidiOutAlsa::closePort(); // Cleanup. AlsaMidiData *data = static_cast (apiData_); if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport ); if ( data->coder ) snd_midi_event_free( data->coder ); if ( data->buffer ) free( data->buffer ); snd_seq_close( data->seq ); delete data; } void MidiOutAlsa :: initialize( const std::string& clientName ) { // Set up the ALSA sequencer client. snd_seq_t *seq; int result1 = snd_seq_open( &seq, "default", SND_SEQ_OPEN_OUTPUT, SND_SEQ_NONBLOCK ); if ( result1 < 0 ) { errorString_ = "MidiOutAlsa::initialize: error creating ALSA sequencer client object."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Set client name. snd_seq_set_client_name( seq, clientName.c_str() ); // Save our api-specific connection information. AlsaMidiData *data = (AlsaMidiData *) new AlsaMidiData; data->seq = seq; data->portNum = -1; data->vport = -1; data->bufferSize = 32; data->coder = 0; data->buffer = 0; int result = snd_midi_event_new( data->bufferSize, &data->coder ); if ( result < 0 ) { delete data; errorString_ = "MidiOutAlsa::initialize: error initializing MIDI event parser!\n\n"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } data->buffer = (unsigned char *) malloc( data->bufferSize ); if ( data->buffer == NULL ) { delete data; errorString_ = "MidiOutAlsa::initialize: error allocating buffer memory!\n\n"; error( RtMidiError::MEMORY_ERROR, errorString_ ); return; } snd_midi_event_init( data->coder ); apiData_ = (void *) data; } unsigned int MidiOutAlsa :: getPortCount() { snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); AlsaMidiData *data = static_cast (apiData_); return portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, -1 ); } std::string MidiOutAlsa :: getPortName( unsigned int portNumber ) { snd_seq_client_info_t *cinfo; snd_seq_port_info_t *pinfo; snd_seq_client_info_alloca( &cinfo ); snd_seq_port_info_alloca( &pinfo ); std::string stringName; AlsaMidiData *data = static_cast (apiData_); if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, (int) portNumber ) ) { int cnum = snd_seq_port_info_get_client( pinfo ); snd_seq_get_any_client_info( data->seq, cnum, cinfo ); std::ostringstream os; os << snd_seq_client_info_get_name( cinfo ); os << ":"; os << snd_seq_port_info_get_name( pinfo ); os << " "; // These lines added to make sure devices are listed os << snd_seq_port_info_get_client( pinfo ); // with full portnames added to ensure individual device names os << ":"; os << snd_seq_port_info_get_port( pinfo ); stringName = os.str(); return stringName; } // If we get here, we didn't find a match. errorString_ = "MidiOutAlsa::getPortName: error looking for port name!"; error( RtMidiError::WARNING, errorString_ ); return stringName; } void MidiOutAlsa :: openPort( unsigned int portNumber, const std::string &portName ) { if ( connected_ ) { errorString_ = "MidiOutAlsa::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } unsigned int nSrc = this->getPortCount(); if ( nSrc < 1 ) { errorString_ = "MidiOutAlsa::openPort: no MIDI output sources found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); AlsaMidiData *data = static_cast (apiData_); if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, (int) portNumber ) == 0 ) { std::ostringstream ost; ost << "MidiOutAlsa::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } snd_seq_addr_t sender, receiver; receiver.client = snd_seq_port_info_get_client( pinfo ); receiver.port = snd_seq_port_info_get_port( pinfo ); sender.client = snd_seq_client_id( data->seq ); if ( data->vport < 0 ) { data->vport = snd_seq_create_simple_port( data->seq, portName.c_str(), SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION ); if ( data->vport < 0 ) { errorString_ = "MidiOutAlsa::openPort: ALSA error creating output port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } } sender.port = data->vport; // Make subscription if ( snd_seq_port_subscribe_malloc( &data->subscription ) < 0 ) { snd_seq_port_subscribe_free( data->subscription ); errorString_ = "MidiOutAlsa::openPort: error allocating port subscription."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } snd_seq_port_subscribe_set_sender( data->subscription, &sender ); snd_seq_port_subscribe_set_dest( data->subscription, &receiver ); snd_seq_port_subscribe_set_time_update( data->subscription, 1 ); snd_seq_port_subscribe_set_time_real( data->subscription, 1 ); if ( snd_seq_subscribe_port( data->seq, data->subscription ) ) { snd_seq_port_subscribe_free( data->subscription ); errorString_ = "MidiOutAlsa::openPort: ALSA error making port connection."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } connected_ = true; } void MidiOutAlsa :: closePort( void ) { if ( connected_ ) { AlsaMidiData *data = static_cast (apiData_); snd_seq_unsubscribe_port( data->seq, data->subscription ); snd_seq_port_subscribe_free( data->subscription ); data->subscription = 0; connected_ = false; } } void MidiOutAlsa :: setClientName( const std::string &clientName ) { AlsaMidiData *data = static_cast ( apiData_ ); snd_seq_set_client_name( data->seq, clientName.c_str() ); } void MidiOutAlsa :: setPortName( const std::string &portName ) { AlsaMidiData *data = static_cast (apiData_); snd_seq_port_info_t *pinfo; snd_seq_port_info_alloca( &pinfo ); snd_seq_get_port_info( data->seq, data->vport, pinfo ); snd_seq_port_info_set_name( pinfo, portName.c_str() ); snd_seq_set_port_info( data->seq, data->vport, pinfo ); } void MidiOutAlsa :: openVirtualPort( const std::string &portName ) { AlsaMidiData *data = static_cast (apiData_); if ( data->vport < 0 ) { data->vport = snd_seq_create_simple_port( data->seq, portName.c_str(), SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION ); if ( data->vport < 0 ) { errorString_ = "MidiOutAlsa::openVirtualPort: ALSA error creating virtual port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); } } } void MidiOutAlsa :: sendMessage( const unsigned char *message, size_t size ) { int result; AlsaMidiData *data = static_cast (apiData_); unsigned int nBytes = static_cast (size); if ( nBytes > data->bufferSize ) { data->bufferSize = nBytes; result = snd_midi_event_resize_buffer( data->coder, nBytes ); if ( result != 0 ) { errorString_ = "MidiOutAlsa::sendMessage: ALSA error resizing MIDI event buffer."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } free (data->buffer); data->buffer = (unsigned char *) malloc( data->bufferSize ); if ( data->buffer == NULL ) { errorString_ = "MidiOutAlsa::initialize: error allocating buffer memory!\n\n"; error( RtMidiError::MEMORY_ERROR, errorString_ ); return; } } snd_seq_event_t ev; snd_seq_ev_clear( &ev ); snd_seq_ev_set_source( &ev, data->vport ); snd_seq_ev_set_subs( &ev ); snd_seq_ev_set_direct( &ev ); for ( unsigned int i=0; ibuffer[i] = message[i]; result = snd_midi_event_encode( data->coder, data->buffer, (long)nBytes, &ev ); if ( result < (int)nBytes ) { errorString_ = "MidiOutAlsa::sendMessage: event parsing error!"; error( RtMidiError::WARNING, errorString_ ); return; } // Send the event. result = snd_seq_event_output( data->seq, &ev ); if ( result < 0 ) { errorString_ = "MidiOutAlsa::sendMessage: error sending MIDI message to port."; error( RtMidiError::WARNING, errorString_ ); return; } snd_seq_drain_output( data->seq ); } #endif // __LINUX_ALSA__ //*********************************************************************// // API: Windows Multimedia Library (MM) //*********************************************************************// // API information deciphered from: // - http://msdn.microsoft.com/library/default.asp?url=/library/en-us/multimed/htm/_win32_midi_reference.asp // Thanks to Jean-Baptiste Berruchon for the sysex code. #if defined(__WINDOWS_MM__) // The Windows MM API is based on the use of a callback function for // MIDI input. We convert the system specific time stamps to delta // time values. // Windows MM MIDI header files. #include #include // Convert a null-terminated wide string or ANSI-encoded string to UTF-8. static std::string ConvertToUTF8(const TCHAR *str) { std::string u8str; const WCHAR *wstr = L""; #if defined( UNICODE ) || defined( _UNICODE ) wstr = str; #else // Convert from ANSI encoding to wide string int wlength = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); std::wstring wstrtemp; if ( wlength ) { wstrtemp.assign( wlength - 1, 0 ); MultiByteToWideChar( CP_ACP, 0, str, -1, &wstrtemp[0], wlength ); wstr = &wstrtemp[0]; } #endif // Convert from wide string to UTF-8 int length = WideCharToMultiByte( CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL ); if ( length ) { u8str.assign( length - 1, 0 ); length = WideCharToMultiByte( CP_UTF8, 0, wstr, -1, &u8str[0], length, NULL, NULL ); } return u8str; } #define RT_SYSEX_BUFFER_SIZE 8096 #define RT_SYSEX_BUFFER_COUNT 4 // A structure to hold variables related to the CoreMIDI API // implementation. struct WinMidiData { HMIDIIN inHandle; // Handle to Midi Input Device HMIDIOUT outHandle; // Handle to Midi Output Device DWORD lastTime; MidiInApi::MidiMessage message; LPMIDIHDR sysexBuffer[RT_SYSEX_BUFFER_COUNT]; CRITICAL_SECTION _mutex; // [Patrice] see https://groups.google.com/forum/#!topic/mididev/6OUjHutMpEo }; //*********************************************************************// // API: Windows MM // Class Definitions: MidiInWinMM //*********************************************************************// static void CALLBACK midiInputCallback( HMIDIIN /*hmin*/, UINT inputStatus, DWORD_PTR instancePtr, DWORD_PTR midiMessage, DWORD timestamp ) { if ( inputStatus != MIM_DATA && inputStatus != MIM_LONGDATA && inputStatus != MIM_LONGERROR ) return; //MidiInApi::RtMidiInData *data = static_cast (instancePtr); MidiInApi::RtMidiInData *data = (MidiInApi::RtMidiInData *)instancePtr; WinMidiData *apiData = static_cast (data->apiData); // Calculate time stamp. if ( data->firstMessage == true ) { apiData->message.timeStamp = 0.0; data->firstMessage = false; } else apiData->message.timeStamp = (double) ( timestamp - apiData->lastTime ) * 0.001; if ( inputStatus == MIM_DATA ) { // Channel or system message // Make sure the first byte is a status byte. unsigned char status = (unsigned char) (midiMessage & 0x000000FF); if ( !(status & 0x80) ) return; // Determine the number of bytes in the MIDI message. unsigned short nBytes = 1; if ( status < 0xC0 ) nBytes = 3; else if ( status < 0xE0 ) nBytes = 2; else if ( status < 0xF0 ) nBytes = 3; else if ( status == 0xF1 ) { if ( data->ignoreFlags & 0x02 ) return; else nBytes = 2; } else if ( status == 0xF2 ) nBytes = 3; else if ( status == 0xF3 ) nBytes = 2; else if ( status == 0xF8 && ( data->ignoreFlags & 0x02 ) ) { // A MIDI timing tick message and we're ignoring it. return; } else if ( status == 0xFE && ( data->ignoreFlags & 0x04 ) ) { // A MIDI active sensing message and we're ignoring it. return; } // Copy bytes to our MIDI message. unsigned char *ptr = (unsigned char *) &midiMessage; for ( int i=0; imessage.bytes.push_back( *ptr++ ); } else { // Sysex message ( MIM_LONGDATA or MIM_LONGERROR ) MIDIHDR *sysex = ( MIDIHDR *) midiMessage; if ( !( data->ignoreFlags & 0x01 ) && inputStatus != MIM_LONGERROR ) { // Sysex message and we're not ignoring it for ( int i=0; i<(int)sysex->dwBytesRecorded; ++i ) apiData->message.bytes.push_back( sysex->lpData[i] ); } // The WinMM API requires that the sysex buffer be requeued after // input of each sysex message. Even if we are ignoring sysex // messages, we still need to requeue the buffer in case the user // decides to not ignore sysex messages in the future. However, // it seems that WinMM calls this function with an empty sysex // buffer when an application closes and in this case, we should // avoid requeueing it, else the computer suddenly reboots after // one or two minutes. if ( apiData->sysexBuffer[sysex->dwUser]->dwBytesRecorded > 0 ) { //if ( sysex->dwBytesRecorded > 0 ) { EnterCriticalSection( &(apiData->_mutex) ); MMRESULT result = midiInAddBuffer( apiData->inHandle, apiData->sysexBuffer[sysex->dwUser], sizeof(MIDIHDR) ); LeaveCriticalSection( &(apiData->_mutex) ); if ( result != MMSYSERR_NOERROR ) std::cerr << "\nRtMidiIn::midiInputCallback: error sending sysex to Midi device!!\n\n"; if ( data->ignoreFlags & 0x01 ) return; } else return; } // Save the time of the last non-filtered message apiData->lastTime = timestamp; if ( data->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback; callback( apiData->message.timeStamp, &apiData->message.bytes, data->userData ); } else { // As long as we haven't reached our queue size limit, push the message. if ( !data->queue.push( apiData->message ) ) std::cerr << "\nMidiInWinMM: message queue limit reached!!\n\n"; } // Clear the vector for the next input message. apiData->message.bytes.clear(); } MidiInWinMM :: MidiInWinMM( const std::string &clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { MidiInWinMM::initialize( clientName ); } MidiInWinMM :: ~MidiInWinMM() { // Close a connection if it exists. MidiInWinMM::closePort(); WinMidiData *data = static_cast (apiData_); DeleteCriticalSection( &(data->_mutex) ); // Cleanup. delete data; } void MidiInWinMM :: initialize( const std::string& /*clientName*/ ) { // We'll issue a warning here if no devices are available but not // throw an error since the user can plugin something later. unsigned int nDevices = midiInGetNumDevs(); if ( nDevices == 0 ) { errorString_ = "MidiInWinMM::initialize: no MIDI input devices currently available."; error( RtMidiError::WARNING, errorString_ ); } // Save our api-specific connection information. WinMidiData *data = (WinMidiData *) new WinMidiData; apiData_ = (void *) data; inputData_.apiData = (void *) data; data->message.bytes.clear(); // needs to be empty for first input message if ( !InitializeCriticalSectionAndSpinCount( &(data->_mutex), 0x00000400 ) ) { errorString_ = "MidiInWinMM::initialize: InitializeCriticalSectionAndSpinCount failed."; error( RtMidiError::WARNING, errorString_ ); } } void MidiInWinMM :: openPort( unsigned int portNumber, const std::string &/*portName*/ ) { if ( connected_ ) { errorString_ = "MidiInWinMM::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } unsigned int nDevices = midiInGetNumDevs(); if (nDevices == 0) { errorString_ = "MidiInWinMM::openPort: no MIDI input sources found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } if ( portNumber >= nDevices ) { std::ostringstream ost; ost << "MidiInWinMM::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } WinMidiData *data = static_cast (apiData_); MMRESULT result = midiInOpen( &data->inHandle, portNumber, (DWORD_PTR)&midiInputCallback, (DWORD_PTR)&inputData_, CALLBACK_FUNCTION ); if ( result != MMSYSERR_NOERROR ) { errorString_ = "MidiInWinMM::openPort: error creating Windows MM MIDI input port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Allocate and init the sysex buffers. for ( int i=0; isysexBuffer[i] = (MIDIHDR*) new char[ sizeof(MIDIHDR) ]; data->sysexBuffer[i]->lpData = new char[ RT_SYSEX_BUFFER_SIZE ]; data->sysexBuffer[i]->dwBufferLength = RT_SYSEX_BUFFER_SIZE; data->sysexBuffer[i]->dwUser = i; // We use the dwUser parameter as buffer indicator data->sysexBuffer[i]->dwFlags = 0; result = midiInPrepareHeader( data->inHandle, data->sysexBuffer[i], sizeof(MIDIHDR) ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); data->inHandle = 0; errorString_ = "MidiInWinMM::openPort: error starting Windows MM MIDI input port (PrepareHeader)."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Register the buffer. result = midiInAddBuffer( data->inHandle, data->sysexBuffer[i], sizeof(MIDIHDR) ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); data->inHandle = 0; errorString_ = "MidiInWinMM::openPort: error starting Windows MM MIDI input port (AddBuffer)."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } } result = midiInStart( data->inHandle ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); data->inHandle = 0; errorString_ = "MidiInWinMM::openPort: error starting Windows MM MIDI input port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } connected_ = true; } void MidiInWinMM :: openVirtualPort( const std::string &/*portName*/ ) { // This function cannot be implemented for the Windows MM MIDI API. errorString_ = "MidiInWinMM::openVirtualPort: cannot be implemented in Windows MM MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiInWinMM :: closePort( void ) { if ( connected_ ) { WinMidiData *data = static_cast (apiData_); EnterCriticalSection( &(data->_mutex) ); midiInReset( data->inHandle ); midiInStop( data->inHandle ); for ( int i=0; iinHandle, data->sysexBuffer[i], sizeof(MIDIHDR)); delete [] data->sysexBuffer[i]->lpData; delete [] data->sysexBuffer[i]; if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); data->inHandle = 0; errorString_ = "MidiInWinMM::openPort: error closing Windows MM MIDI input port (midiInUnprepareHeader)."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } } midiInClose( data->inHandle ); data->inHandle = 0; connected_ = false; LeaveCriticalSection( &(data->_mutex) ); } } void MidiInWinMM :: setClientName ( const std::string& ) { errorString_ = "MidiInWinMM::setClientName: this function is not implemented for the WINDOWS_MM API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiInWinMM :: setPortName ( const std::string& ) { errorString_ = "MidiInWinMM::setPortName: this function is not implemented for the WINDOWS_MM API!"; error( RtMidiError::WARNING, errorString_ ); } unsigned int MidiInWinMM :: getPortCount() { return midiInGetNumDevs(); } std::string MidiInWinMM :: getPortName( unsigned int portNumber ) { std::string stringName; unsigned int nDevices = midiInGetNumDevs(); if ( portNumber >= nDevices ) { std::ostringstream ost; ost << "MidiInWinMM::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::WARNING, errorString_ ); return stringName; } MIDIINCAPS deviceCaps; midiInGetDevCaps( portNumber, &deviceCaps, sizeof(MIDIINCAPS)); stringName = ConvertToUTF8( deviceCaps.szPname ); // Next lines added to add the portNumber to the name so that // the device's names are sure to be listed with individual names // even when they have the same brand name #ifndef RTMIDI_DO_NOT_ENSURE_UNIQUE_PORTNAMES std::ostringstream os; os << " "; os << portNumber; stringName += os.str(); #endif return stringName; } //*********************************************************************// // API: Windows MM // Class Definitions: MidiOutWinMM //*********************************************************************// MidiOutWinMM :: MidiOutWinMM( const std::string &clientName ) : MidiOutApi() { MidiOutWinMM::initialize( clientName ); } MidiOutWinMM :: ~MidiOutWinMM() { // Close a connection if it exists. MidiOutWinMM::closePort(); // Cleanup. WinMidiData *data = static_cast (apiData_); delete data; } void MidiOutWinMM :: initialize( const std::string& /*clientName*/ ) { // We'll issue a warning here if no devices are available but not // throw an error since the user can plug something in later. unsigned int nDevices = midiOutGetNumDevs(); if ( nDevices == 0 ) { errorString_ = "MidiOutWinMM::initialize: no MIDI output devices currently available."; error( RtMidiError::WARNING, errorString_ ); } // Save our api-specific connection information. WinMidiData *data = (WinMidiData *) new WinMidiData; apiData_ = (void *) data; } unsigned int MidiOutWinMM :: getPortCount() { return midiOutGetNumDevs(); } std::string MidiOutWinMM :: getPortName( unsigned int portNumber ) { std::string stringName; unsigned int nDevices = midiOutGetNumDevs(); if ( portNumber >= nDevices ) { std::ostringstream ost; ost << "MidiOutWinMM::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::WARNING, errorString_ ); return stringName; } MIDIOUTCAPS deviceCaps; midiOutGetDevCaps( portNumber, &deviceCaps, sizeof( MIDIOUTCAPS ) ); stringName = ConvertToUTF8( deviceCaps.szPname ); // Next lines added to add the portNumber to the name so that // the device's names are sure to be listed with individual names // even when they have the same brand name std::ostringstream os; #ifndef RTMIDI_DO_NOT_ENSURE_UNIQUE_PORTNAMES os << " "; os << portNumber; stringName += os.str(); #endif return stringName; } void MidiOutWinMM :: openPort( unsigned int portNumber, const std::string &/*portName*/ ) { if ( connected_ ) { errorString_ = "MidiOutWinMM::openPort: a valid connection already exists!"; error( RtMidiError::WARNING, errorString_ ); return; } unsigned int nDevices = midiOutGetNumDevs(); if ( nDevices < 1 ) { errorString_ = "MidiOutWinMM::openPort: no MIDI output destinations found!"; error( RtMidiError::NO_DEVICES_FOUND, errorString_ ); return; } if ( portNumber >= nDevices ) { std::ostringstream ost; ost << "MidiOutWinMM::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::INVALID_PARAMETER, errorString_ ); return; } WinMidiData *data = static_cast (apiData_); MMRESULT result = midiOutOpen( &data->outHandle, portNumber, (DWORD)NULL, (DWORD)NULL, CALLBACK_NULL ); if ( result != MMSYSERR_NOERROR ) { errorString_ = "MidiOutWinMM::openPort: error creating Windows MM MIDI output port."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } connected_ = true; } void MidiOutWinMM :: closePort( void ) { if ( connected_ ) { WinMidiData *data = static_cast (apiData_); midiOutReset( data->outHandle ); midiOutClose( data->outHandle ); data->outHandle = 0; connected_ = false; } } void MidiOutWinMM :: setClientName ( const std::string& ) { errorString_ = "MidiOutWinMM::setClientName: this function is not implemented for the WINDOWS_MM API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutWinMM :: setPortName ( const std::string& ) { errorString_ = "MidiOutWinMM::setPortName: this function is not implemented for the WINDOWS_MM API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutWinMM :: openVirtualPort( const std::string &/*portName*/ ) { // This function cannot be implemented for the Windows MM MIDI API. errorString_ = "MidiOutWinMM::openVirtualPort: cannot be implemented in Windows MM MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutWinMM :: sendMessage( const unsigned char *message, size_t size ) { if ( !connected_ ) return; unsigned int nBytes = static_cast(size); if ( nBytes == 0 ) { errorString_ = "MidiOutWinMM::sendMessage: message argument is empty!"; error( RtMidiError::WARNING, errorString_ ); return; } MMRESULT result; WinMidiData *data = static_cast (apiData_); if ( message[0] == 0xF0 ) { // Sysex message // Allocate buffer for sysex data. char *buffer = (char *) malloc( nBytes ); if ( buffer == NULL ) { errorString_ = "MidiOutWinMM::sendMessage: error allocating sysex message memory!"; error( RtMidiError::MEMORY_ERROR, errorString_ ); return; } // Copy data to buffer. for ( unsigned int i=0; ioutHandle, &sysex, sizeof( MIDIHDR ) ); if ( result != MMSYSERR_NOERROR ) { free( buffer ); errorString_ = "MidiOutWinMM::sendMessage: error preparing sysex header."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Send the message. result = midiOutLongMsg( data->outHandle, &sysex, sizeof( MIDIHDR ) ); if ( result != MMSYSERR_NOERROR ) { free( buffer ); errorString_ = "MidiOutWinMM::sendMessage: error sending sysex message."; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Unprepare the buffer and MIDIHDR. while ( MIDIERR_STILLPLAYING == midiOutUnprepareHeader( data->outHandle, &sysex, sizeof ( MIDIHDR ) ) ) Sleep( 1 ); free( buffer ); } else { // Channel or system message. // Make sure the message size isn't too big. if ( nBytes > 3 ) { errorString_ = "MidiOutWinMM::sendMessage: message size is greater than 3 bytes (and not sysex)!"; error( RtMidiError::WARNING, errorString_ ); return; } // Pack MIDI bytes into double word. DWORD packet; unsigned char *ptr = (unsigned char *) &packet; for ( unsigned int i=0; ioutHandle, packet ); if ( result != MMSYSERR_NOERROR ) { errorString_ = "MidiOutWinMM::sendMessage: error sending MIDI message."; error( RtMidiError::DRIVER_ERROR, errorString_ ); } } } #endif // __WINDOWS_MM__ //*********************************************************************// // API: UNIX JACK // // Written primarily by Alexander Svetalkin, with updates for delta // time by Gary Scavone, April 2011. // // *********************************************************************// #if defined(__UNIX_JACK__) // JACK header files #include #include #include #ifdef HAVE_SEMAPHORE #include #endif #define JACK_RINGBUFFER_SIZE 16384 // Default size for ringbuffer struct JackMidiData { jack_client_t *client; jack_port_t *port; jack_ringbuffer_t *buffSize; jack_ringbuffer_t *buffMessage; jack_time_t lastTime; #ifdef HAVE_SEMAPHORE sem_t sem_cleanup; sem_t sem_needpost; #endif MidiInApi :: RtMidiInData *rtMidiIn; }; //*********************************************************************// // API: JACK // Class Definitions: MidiInJack //*********************************************************************// static int jackProcessIn( jack_nframes_t nframes, void *arg ) { JackMidiData *jData = (JackMidiData *) arg; MidiInApi :: RtMidiInData *rtData = jData->rtMidiIn; jack_midi_event_t event; jack_time_t time; // Is port created? if ( jData->port == NULL ) return 0; void *buff = jack_port_get_buffer( jData->port, nframes ); bool& continueSysex = rtData->continueSysex; unsigned char& ignoreFlags = rtData->ignoreFlags; // We have midi events in buffer int evCount = jack_midi_get_event_count( buff ); for (int j = 0; j < evCount; j++) { MidiInApi::MidiMessage& message = rtData->message; jack_midi_event_get( &event, buff, j ); // Compute the delta time. time = jack_get_time(); if ( rtData->firstMessage == true ) { message.timeStamp = 0.0; rtData->firstMessage = false; } else message.timeStamp = ( time - jData->lastTime ) * 0.000001; jData->lastTime = time; if ( !continueSysex ) message.bytes.clear(); if ( !( ( continueSysex || event.buffer[0] == 0xF0 ) && ( ignoreFlags & 0x01 ) ) ) { // Unless this is a (possibly continued) SysEx message and we're ignoring SysEx, // copy the event buffer into the MIDI message struct. for ( unsigned int i = 0; i < event.size; i++ ) message.bytes.push_back( event.buffer[i] ); } switch ( event.buffer[0] ) { case 0xF0: // Start of a SysEx message continueSysex = event.buffer[event.size - 1] != 0xF7; if ( ignoreFlags & 0x01 ) continue; break; case 0xF1: case 0xF8: // MIDI Time Code or Timing Clock message if ( ignoreFlags & 0x02 ) continue; break; case 0xFE: // Active Sensing message if ( ignoreFlags & 0x04 ) continue; break; default: if ( continueSysex ) { // Continuation of a SysEx message continueSysex = event.buffer[event.size - 1] != 0xF7; if ( ignoreFlags & 0x01 ) continue; } // All other MIDI messages } if ( !continueSysex ) { // If not a continuation of a SysEx message, // invoke the user callback function or queue the message. if ( rtData->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) rtData->userCallback; callback( message.timeStamp, &message.bytes, rtData->userData ); } else { // As long as we haven't reached our queue size limit, push the message. if ( !rtData->queue.push( message ) ) std::cerr << "\nMidiInJack: message queue limit reached!!\n\n"; } } } return 0; } MidiInJack :: MidiInJack( const std::string &clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { MidiInJack::initialize( clientName ); } void MidiInJack :: initialize( const std::string& clientName ) { JackMidiData *data = new JackMidiData; apiData_ = (void *) data; data->rtMidiIn = &inputData_; data->port = NULL; data->client = NULL; this->clientName = clientName; connect(); } void MidiInJack :: connect() { JackMidiData *data = static_cast (apiData_); if ( data->client ) return; // Initialize JACK client if (( data->client = jack_client_open( clientName.c_str(), JackNoStartServer, NULL )) == 0) { errorString_ = "MidiInJack::initialize: JACK server not running?"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } jack_set_process_callback( data->client, jackProcessIn, data ); jack_activate( data->client ); } MidiInJack :: ~MidiInJack() { JackMidiData *data = static_cast (apiData_); MidiInJack::closePort(); if ( data->client ) jack_client_close( data->client ); delete data; } void MidiInJack :: openPort( unsigned int portNumber, const std::string &portName ) { JackMidiData *data = static_cast (apiData_); connect(); // Creating new port if ( data->port == NULL ) data->port = jack_port_register( data->client, portName.c_str(), JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0 ); if ( data->port == NULL ) { errorString_ = "MidiInJack::openPort: JACK error creating port"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Connecting to the output std::string name = getPortName( portNumber ); jack_connect( data->client, name.c_str(), jack_port_name( data->port ) ); connected_ = true; } void MidiInJack :: openVirtualPort( const std::string &portName ) { JackMidiData *data = static_cast (apiData_); connect(); if ( data->port == NULL ) data->port = jack_port_register( data->client, portName.c_str(), JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0 ); if ( data->port == NULL ) { errorString_ = "MidiInJack::openVirtualPort: JACK error creating virtual port"; error( RtMidiError::DRIVER_ERROR, errorString_ ); } } unsigned int MidiInJack :: getPortCount() { int count = 0; JackMidiData *data = static_cast (apiData_); connect(); if ( !data->client ) return 0; // List of available ports const char **ports = jack_get_ports( data->client, NULL, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput ); if ( ports == NULL ) return 0; while ( ports[count] != NULL ) count++; free( ports ); return count; } std::string MidiInJack :: getPortName( unsigned int portNumber ) { JackMidiData *data = static_cast (apiData_); std::string retStr( "" ); connect(); // List of available ports const char **ports = jack_get_ports( data->client, NULL, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput ); // Check port validity if ( ports == NULL ) { errorString_ = "MidiInJack::getPortName: no ports available!"; error( RtMidiError::WARNING, errorString_ ); return retStr; } unsigned int i; for ( i=0; i (apiData_); if ( data->port == NULL ) return; jack_port_unregister( data->client, data->port ); data->port = NULL; connected_ = false; } void MidiInJack:: setClientName( const std::string& ) { errorString_ = "MidiInJack::setClientName: this function is not implemented for the UNIX_JACK API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiInJack :: setPortName( const std::string &portName ) { JackMidiData *data = static_cast (apiData_); #ifdef JACK_HAS_PORT_RENAME jack_port_rename( data->client, data->port, portName.c_str() ); #else jack_port_set_name( data->port, portName.c_str() ); #endif } //*********************************************************************// // API: JACK // Class Definitions: MidiOutJack //*********************************************************************// // Jack process callback static int jackProcessOut( jack_nframes_t nframes, void *arg ) { JackMidiData *data = (JackMidiData *) arg; jack_midi_data_t *midiData; int space; // Is port created? if ( data->port == NULL ) return 0; void *buff = jack_port_get_buffer( data->port, nframes ); jack_midi_clear_buffer( buff ); while ( jack_ringbuffer_read_space( data->buffSize ) > 0 ) { jack_ringbuffer_read( data->buffSize, (char *) &space, (size_t) sizeof( space ) ); midiData = jack_midi_event_reserve( buff, 0, space ); jack_ringbuffer_read( data->buffMessage, (char *) midiData, (size_t) space ); } #ifdef HAVE_SEMAPHORE if ( !sem_trywait( &data->sem_needpost ) ) sem_post( &data->sem_cleanup ); #endif return 0; } MidiOutJack :: MidiOutJack( const std::string &clientName ) : MidiOutApi() { MidiOutJack::initialize( clientName ); } void MidiOutJack :: initialize( const std::string& clientName ) { JackMidiData *data = new JackMidiData; apiData_ = (void *) data; data->port = NULL; data->client = NULL; #ifdef HAVE_SEMAPHORE sem_init( &data->sem_cleanup, 0, 0 ); sem_init( &data->sem_needpost, 0, 0 ); #endif this->clientName = clientName; connect(); } void MidiOutJack :: connect() { JackMidiData *data = static_cast (apiData_); if ( data->client ) return; // Initialize output ringbuffers data->buffSize = jack_ringbuffer_create( JACK_RINGBUFFER_SIZE ); data->buffMessage = jack_ringbuffer_create( JACK_RINGBUFFER_SIZE ); // Initialize JACK client if ( ( data->client = jack_client_open( clientName.c_str(), JackNoStartServer, NULL ) ) == 0 ) { errorString_ = "MidiOutJack::initialize: JACK server not running?"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } jack_set_process_callback( data->client, jackProcessOut, data ); jack_activate( data->client ); } MidiOutJack :: ~MidiOutJack() { JackMidiData *data = static_cast (apiData_); MidiOutJack::closePort(); // Cleanup jack_ringbuffer_free( data->buffSize ); jack_ringbuffer_free( data->buffMessage ); if ( data->client ) { jack_client_close( data->client ); } #ifdef HAVE_SEMAPHORE sem_destroy( &data->sem_cleanup ); sem_destroy( &data->sem_needpost ); #endif delete data; } void MidiOutJack :: openPort( unsigned int portNumber, const std::string &portName ) { JackMidiData *data = static_cast (apiData_); connect(); // Creating new port if ( data->port == NULL ) data->port = jack_port_register( data->client, portName.c_str(), JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0 ); if ( data->port == NULL ) { errorString_ = "MidiOutJack::openPort: JACK error creating port"; error( RtMidiError::DRIVER_ERROR, errorString_ ); return; } // Connecting to the output std::string name = getPortName( portNumber ); jack_connect( data->client, jack_port_name( data->port ), name.c_str() ); connected_ = true; } void MidiOutJack :: openVirtualPort( const std::string &portName ) { JackMidiData *data = static_cast (apiData_); connect(); if ( data->port == NULL ) data->port = jack_port_register( data->client, portName.c_str(), JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0 ); if ( data->port == NULL ) { errorString_ = "MidiOutJack::openVirtualPort: JACK error creating virtual port"; error( RtMidiError::DRIVER_ERROR, errorString_ ); } } unsigned int MidiOutJack :: getPortCount() { int count = 0; JackMidiData *data = static_cast (apiData_); connect(); if ( !data->client ) return 0; // List of available ports const char **ports = jack_get_ports( data->client, NULL, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput ); if ( ports == NULL ) return 0; while ( ports[count] != NULL ) count++; free( ports ); return count; } std::string MidiOutJack :: getPortName( unsigned int portNumber ) { JackMidiData *data = static_cast (apiData_); std::string retStr(""); connect(); // List of available ports const char **ports = jack_get_ports( data->client, NULL, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput ); // Check port validity if ( ports == NULL ) { errorString_ = "MidiOutJack::getPortName: no ports available!"; error( RtMidiError::WARNING, errorString_ ); return retStr; } if ( ports[portNumber] == NULL ) { std::ostringstream ost; ost << "MidiOutJack::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtMidiError::WARNING, errorString_ ); } else retStr.assign( ports[portNumber] ); free( ports ); return retStr; } void MidiOutJack :: closePort() { JackMidiData *data = static_cast (apiData_); if ( data->port == NULL ) return; #ifdef HAVE_SEMAPHORE struct timespec ts; if ( clock_gettime( CLOCK_REALTIME, &ts ) != -1 ) { ts.tv_sec += 1; // wait max one second sem_post( &data->sem_needpost ); sem_timedwait( &data->sem_cleanup, &ts ); } #endif jack_port_unregister( data->client, data->port ); data->port = NULL; connected_ = false; } void MidiOutJack:: setClientName( const std::string& ) { errorString_ = "MidiOutJack::setClientName: this function is not implemented for the UNIX_JACK API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutJack :: setPortName( const std::string &portName ) { JackMidiData *data = static_cast (apiData_); #ifdef JACK_HAS_PORT_RENAME jack_port_rename( data->client, data->port, portName.c_str() ); #else jack_port_set_name( data->port, portName.c_str() ); #endif } void MidiOutJack :: sendMessage( const unsigned char *message, size_t size ) { int nBytes = static_cast(size); JackMidiData *data = static_cast (apiData_); // Write full message to buffer jack_ringbuffer_write( data->buffMessage, ( const char * ) message, nBytes ); jack_ringbuffer_write( data->buffSize, ( char * ) &nBytes, sizeof( nBytes ) ); } #endif // __UNIX_JACK__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1586886060.0 python-rtmidi-1.4.7/src/rtmidi/RtMidi.h0000644000175000001440000006205700000000000017014 0ustar00chrisusers/**********************************************************************/ /*! \class RtMidi \brief An abstract base class for realtime MIDI input/output. This class implements some common functionality for the realtime MIDI input/output subclasses RtMidiIn and RtMidiOut. RtMidi GitHub site: https://github.com/thestk/rtmidi RtMidi WWW site: http://www.music.mcgill.ca/~gary/rtmidi/ RtMidi: realtime MIDI i/o C++ classes Copyright (c) 2003-2019 Gary P. Scavone Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Any person wishing to distribute modifications to the Software is asked to send the modifications to the original developer so that they can be incorporated into the canonical version. This is, however, not a binding provision of this license. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**********************************************************************/ /*! \file RtMidi.h */ #ifndef RTMIDI_H #define RTMIDI_H #if defined _WIN32 || defined __CYGWIN__ #if defined(RTMIDI_EXPORT) #define RTMIDI_DLL_PUBLIC __declspec(dllexport) #else #define RTMIDI_DLL_PUBLIC #endif #else #if __GNUC__ >= 4 #define RTMIDI_DLL_PUBLIC __attribute__( (visibility( "default" )) ) #else #define RTMIDI_DLL_PUBLIC #endif #endif #define RTMIDI_VERSION "4.0.0" #include #include #include #include /************************************************************************/ /*! \class RtMidiError \brief Exception handling class for RtMidi. The RtMidiError class is quite simple but it does allow errors to be "caught" by RtMidiError::Type. See the RtMidi documentation to know which methods can throw an RtMidiError. */ /************************************************************************/ class RTMIDI_DLL_PUBLIC RtMidiError : public std::exception { public: //! Defined RtMidiError types. enum Type { WARNING, /*!< A non-critical error. */ DEBUG_WARNING, /*!< A non-critical error which might be useful for debugging. */ UNSPECIFIED, /*!< The default, unspecified error type. */ NO_DEVICES_FOUND, /*!< No devices found on system. */ INVALID_DEVICE, /*!< An invalid device ID was specified. */ MEMORY_ERROR, /*!< An error occured during memory allocation. */ INVALID_PARAMETER, /*!< An invalid parameter was specified to a function. */ INVALID_USE, /*!< The function was called incorrectly. */ DRIVER_ERROR, /*!< A system driver error occured. */ SYSTEM_ERROR, /*!< A system error occured. */ THREAD_ERROR /*!< A thread error occured. */ }; //! The constructor. RtMidiError( const std::string& message, Type type = RtMidiError::UNSPECIFIED ) throw() : message_(message), type_(type) {} //! The destructor. virtual ~RtMidiError( void ) throw() {} //! Prints thrown error message to stderr. virtual void printMessage( void ) const throw() { std::cerr << '\n' << message_ << "\n\n"; } //! Returns the thrown error message type. virtual const Type& getType( void ) const throw() { return type_; } //! Returns the thrown error message string. virtual const std::string& getMessage( void ) const throw() { return message_; } //! Returns the thrown error message as a c-style string. virtual const char* what( void ) const throw() { return message_.c_str(); } protected: std::string message_; Type type_; }; //! RtMidi error callback function prototype. /*! \param type Type of error. \param errorText Error description. Note that class behaviour is undefined after a critical error (not a warning) is reported. */ typedef void (*RtMidiErrorCallback)( RtMidiError::Type type, const std::string &errorText, void *userData ); class MidiApi; class RTMIDI_DLL_PUBLIC RtMidi { public: //! MIDI API specifier arguments. enum Api { UNSPECIFIED, /*!< Search for a working compiled API. */ MACOSX_CORE, /*!< Macintosh OS-X CoreMIDI API. */ LINUX_ALSA, /*!< The Advanced Linux Sound Architecture API. */ UNIX_JACK, /*!< The JACK Low-Latency MIDI Server API. */ WINDOWS_MM, /*!< The Microsoft Multimedia MIDI API. */ RTMIDI_DUMMY, /*!< A compilable but non-functional API. */ NUM_APIS /*!< Number of values in this enum. */ }; //! A static function to determine the current RtMidi version. static std::string getVersion( void ) throw(); //! A static function to determine the available compiled MIDI APIs. /*! The values returned in the std::vector can be compared against the enumerated list values. Note that there can be more than one API compiled for certain operating systems. */ static void getCompiledApi( std::vector &apis ) throw(); //! Return the name of a specified compiled MIDI API. /*! This obtains a short lower-case name used for identification purposes. This value is guaranteed to remain identical across library versions. If the API is unknown, this function will return the empty string. */ static std::string getApiName( RtMidi::Api api ); //! Return the display name of a specified compiled MIDI API. /*! This obtains a long name used for display purposes. If the API is unknown, this function will return the empty string. */ static std::string getApiDisplayName( RtMidi::Api api ); //! Return the compiled MIDI API having the given name. /*! A case insensitive comparison will check the specified name against the list of compiled APIs, and return the one which matches. On failure, the function returns UNSPECIFIED. */ static RtMidi::Api getCompiledApiByName( const std::string &name ); //! Pure virtual openPort() function. virtual void openPort( unsigned int portNumber = 0, const std::string &portName = std::string( "RtMidi" ) ) = 0; //! Pure virtual openVirtualPort() function. virtual void openVirtualPort( const std::string &portName = std::string( "RtMidi" ) ) = 0; //! Pure virtual getPortCount() function. virtual unsigned int getPortCount() = 0; //! Pure virtual getPortName() function. virtual std::string getPortName( unsigned int portNumber = 0 ) = 0; //! Pure virtual closePort() function. virtual void closePort( void ) = 0; void setClientName( const std::string &clientName ); void setPortName( const std::string &portName ); //! Returns true if a port is open and false if not. /*! Note that this only applies to connections made with the openPort() function, not to virtual ports. */ virtual bool isPortOpen( void ) const = 0; //! Set an error callback function to be invoked when an error has occured. /*! The callback function will be called whenever an error has occured. It is best to set the error callback function before opening a port. */ virtual void setErrorCallback( RtMidiErrorCallback errorCallback = NULL, void *userData = 0 ) = 0; protected: RtMidi(); virtual ~RtMidi(); MidiApi *rtapi_; }; /**********************************************************************/ /*! \class RtMidiIn \brief A realtime MIDI input class. This class provides a common, platform-independent API for realtime MIDI input. It allows access to a single MIDI input port. Incoming MIDI messages are either saved to a queue for retrieval using the getMessage() function or immediately passed to a user-specified callback function. Create multiple instances of this class to connect to more than one MIDI device at the same time. With the OS-X, Linux ALSA, and JACK MIDI APIs, it is also possible to open a virtual input port to which other MIDI software clients can connect. */ /**********************************************************************/ // **************************************************************** // // // RtMidiIn and RtMidiOut class declarations. // // RtMidiIn / RtMidiOut are "controllers" used to select an available // MIDI input or output interface. They present common APIs for the // user to call but all functionality is implemented by the classes // MidiInApi, MidiOutApi and their subclasses. RtMidiIn and RtMidiOut // each create an instance of a MidiInApi or MidiOutApi subclass based // on the user's API choice. If no choice is made, they attempt to // make a "logical" API selection. // // **************************************************************** // class RTMIDI_DLL_PUBLIC RtMidiIn : public RtMidi { public: //! User callback function type definition. typedef void (*RtMidiCallback)( double timeStamp, std::vector *message, void *userData ); //! Default constructor that allows an optional api, client name and queue size. /*! An exception will be thrown if a MIDI system initialization error occurs. The queue size defines the maximum number of messages that can be held in the MIDI queue (when not using a callback function). If the queue size limit is reached, incoming messages will be ignored. If no API argument is specified and multiple API support has been compiled, the default order of use is ALSA, JACK (Linux) and CORE, JACK (OS-X). \param api An optional API id can be specified. \param clientName An optional client name can be specified. This will be used to group the ports that are created by the application. \param queueSizeLimit An optional size of the MIDI input queue can be specified. */ RtMidiIn( RtMidi::Api api=UNSPECIFIED, const std::string& clientName = "RtMidi Input Client", unsigned int queueSizeLimit = 100 ); //! If a MIDI connection is still open, it will be closed by the destructor. ~RtMidiIn ( void ) throw(); //! Returns the MIDI API specifier for the current instance of RtMidiIn. RtMidi::Api getCurrentApi( void ) throw(); //! Open a MIDI input connection given by enumeration number. /*! \param portNumber An optional port number greater than 0 can be specified. Otherwise, the default or first port found is opened. \param portName An optional name for the application port that is used to connect to portId can be specified. */ void openPort( unsigned int portNumber = 0, const std::string &portName = std::string( "RtMidi Input" ) ); //! Create a virtual input port, with optional name, to allow software connections (OS X, JACK and ALSA only). /*! This function creates a virtual MIDI input port to which other software applications can connect. This type of functionality is currently only supported by the Macintosh OS-X, any JACK, and Linux ALSA APIs (the function returns an error for the other APIs). \param portName An optional name for the application port that is used to connect to portId can be specified. */ void openVirtualPort( const std::string &portName = std::string( "RtMidi Input" ) ); //! Set a callback function to be invoked for incoming MIDI messages. /*! The callback function will be called whenever an incoming MIDI message is received. While not absolutely necessary, it is best to set the callback function before opening a MIDI port to avoid leaving some messages in the queue. \param callback A callback function must be given. \param userData Optionally, a pointer to additional data can be passed to the callback function whenever it is called. */ void setCallback( RtMidiCallback callback, void *userData = 0 ); //! Cancel use of the current callback function (if one exists). /*! Subsequent incoming MIDI messages will be written to the queue and can be retrieved with the \e getMessage function. */ void cancelCallback(); //! Close an open MIDI connection (if one exists). void closePort( void ); //! Returns true if a port is open and false if not. /*! Note that this only applies to connections made with the openPort() function, not to virtual ports. */ virtual bool isPortOpen() const; //! Return the number of available MIDI input ports. /*! \return This function returns the number of MIDI ports of the selected API. */ unsigned int getPortCount(); //! Return a string identifier for the specified MIDI input port number. /*! \return The name of the port with the given Id is returned. \retval An empty string is returned if an invalid port specifier is provided. User code should assume a UTF-8 encoding. */ std::string getPortName( unsigned int portNumber = 0 ); //! Specify whether certain MIDI message types should be queued or ignored during input. /*! By default, MIDI timing and active sensing messages are ignored during message input because of their relative high data rates. MIDI sysex messages are ignored by default as well. Variable values of "true" imply that the respective message type will be ignored. */ void ignoreTypes( bool midiSysex = true, bool midiTime = true, bool midiSense = true ); //! Fill the user-provided vector with the data bytes for the next available MIDI message in the input queue and return the event delta-time in seconds. /*! This function returns immediately whether a new message is available or not. A valid message is indicated by a non-zero vector size. An exception is thrown if an error occurs during message retrieval or an input connection was not previously established. */ double getMessage( std::vector *message ); //! Set an error callback function to be invoked when an error has occured. /*! The callback function will be called whenever an error has occured. It is best to set the error callback function before opening a port. */ virtual void setErrorCallback( RtMidiErrorCallback errorCallback = NULL, void *userData = 0 ); protected: void openMidiApi( RtMidi::Api api, const std::string &clientName, unsigned int queueSizeLimit ); }; /**********************************************************************/ /*! \class RtMidiOut \brief A realtime MIDI output class. This class provides a common, platform-independent API for MIDI output. It allows one to probe available MIDI output ports, to connect to one such port, and to send MIDI bytes immediately over the connection. Create multiple instances of this class to connect to more than one MIDI device at the same time. With the OS-X, Linux ALSA and JACK MIDI APIs, it is also possible to open a virtual port to which other MIDI software clients can connect. */ /**********************************************************************/ class RTMIDI_DLL_PUBLIC RtMidiOut : public RtMidi { public: //! Default constructor that allows an optional client name. /*! An exception will be thrown if a MIDI system initialization error occurs. If no API argument is specified and multiple API support has been compiled, the default order of use is ALSA, JACK (Linux) and CORE, JACK (OS-X). */ RtMidiOut( RtMidi::Api api=UNSPECIFIED, const std::string& clientName = "RtMidi Output Client" ); //! The destructor closes any open MIDI connections. ~RtMidiOut( void ) throw(); //! Returns the MIDI API specifier for the current instance of RtMidiOut. RtMidi::Api getCurrentApi( void ) throw(); //! Open a MIDI output connection. /*! An optional port number greater than 0 can be specified. Otherwise, the default or first port found is opened. An exception is thrown if an error occurs while attempting to make the port connection. */ void openPort( unsigned int portNumber = 0, const std::string &portName = std::string( "RtMidi Output" ) ); //! Close an open MIDI connection (if one exists). void closePort( void ); //! Returns true if a port is open and false if not. /*! Note that this only applies to connections made with the openPort() function, not to virtual ports. */ virtual bool isPortOpen() const; //! Create a virtual output port, with optional name, to allow software connections (OS X, JACK and ALSA only). /*! This function creates a virtual MIDI output port to which other software applications can connect. This type of functionality is currently only supported by the Macintosh OS-X, Linux ALSA and JACK APIs (the function does nothing with the other APIs). An exception is thrown if an error occurs while attempting to create the virtual port. */ void openVirtualPort( const std::string &portName = std::string( "RtMidi Output" ) ); //! Return the number of available MIDI output ports. unsigned int getPortCount( void ); //! Return a string identifier for the specified MIDI port type and number. /*! \return The name of the port with the given Id is returned. \retval An empty string is returned if an invalid port specifier is provided. User code should assume a UTF-8 encoding. */ std::string getPortName( unsigned int portNumber = 0 ); //! Immediately send a single message out an open MIDI output port. /*! An exception is thrown if an error occurs during output or an output connection was not previously established. */ void sendMessage( const std::vector *message ); //! Immediately send a single message out an open MIDI output port. /*! An exception is thrown if an error occurs during output or an output connection was not previously established. \param message A pointer to the MIDI message as raw bytes \param size Length of the MIDI message in bytes */ void sendMessage( const unsigned char *message, size_t size ); //! Set an error callback function to be invoked when an error has occured. /*! The callback function will be called whenever an error has occured. It is best to set the error callback function before opening a port. */ virtual void setErrorCallback( RtMidiErrorCallback errorCallback = NULL, void *userData = 0 ); protected: void openMidiApi( RtMidi::Api api, const std::string &clientName ); }; // **************************************************************** // // // MidiInApi / MidiOutApi class declarations. // // Subclasses of MidiInApi and MidiOutApi contain all API- and // OS-specific code necessary to fully implement the RtMidi API. // // Note that MidiInApi and MidiOutApi are abstract base classes and // cannot be explicitly instantiated. RtMidiIn and RtMidiOut will // create instances of a MidiInApi or MidiOutApi subclass. // // **************************************************************** // class RTMIDI_DLL_PUBLIC MidiApi { public: MidiApi(); virtual ~MidiApi(); virtual RtMidi::Api getCurrentApi( void ) = 0; virtual void openPort( unsigned int portNumber, const std::string &portName ) = 0; virtual void openVirtualPort( const std::string &portName ) = 0; virtual void closePort( void ) = 0; virtual void setClientName( const std::string &clientName ) = 0; virtual void setPortName( const std::string &portName ) = 0; virtual unsigned int getPortCount( void ) = 0; virtual std::string getPortName( unsigned int portNumber ) = 0; inline bool isPortOpen() const { return connected_; } void setErrorCallback( RtMidiErrorCallback errorCallback, void *userData ); //! A basic error reporting function for RtMidi classes. void error( RtMidiError::Type type, std::string errorString ); protected: virtual void initialize( const std::string& clientName ) = 0; void *apiData_; bool connected_; std::string errorString_; RtMidiErrorCallback errorCallback_; bool firstErrorOccurred_; void *errorCallbackUserData_; }; class RTMIDI_DLL_PUBLIC MidiInApi : public MidiApi { public: MidiInApi( unsigned int queueSizeLimit ); virtual ~MidiInApi( void ); void setCallback( RtMidiIn::RtMidiCallback callback, void *userData ); void cancelCallback( void ); virtual void ignoreTypes( bool midiSysex, bool midiTime, bool midiSense ); double getMessage( std::vector *message ); // A MIDI structure used internally by the class to store incoming // messages. Each message represents one and only one MIDI message. struct MidiMessage { std::vector bytes; //! Time in seconds elapsed since the previous message double timeStamp; // Default constructor. MidiMessage() : bytes(0), timeStamp(0.0) {} }; struct MidiQueue { unsigned int front; unsigned int back; unsigned int ringSize; MidiMessage *ring; // Default constructor. MidiQueue() : front(0), back(0), ringSize(0), ring(0) {} bool push( const MidiMessage& ); bool pop( std::vector*, double* ); unsigned int size( unsigned int *back=0, unsigned int *front=0 ); }; // The RtMidiInData structure is used to pass private class data to // the MIDI input handling function or thread. struct RtMidiInData { MidiQueue queue; MidiMessage message; unsigned char ignoreFlags; bool doInput; bool firstMessage; void *apiData; bool usingCallback; RtMidiIn::RtMidiCallback userCallback; void *userData; bool continueSysex; // Default constructor. RtMidiInData() : ignoreFlags(7), doInput(false), firstMessage(true), apiData(0), usingCallback(false), userCallback(0), userData(0), continueSysex(false) {} }; protected: RtMidiInData inputData_; }; class RTMIDI_DLL_PUBLIC MidiOutApi : public MidiApi { public: MidiOutApi( void ); virtual ~MidiOutApi( void ); virtual void sendMessage( const unsigned char *message, size_t size ) = 0; }; // **************************************************************** // // // Inline RtMidiIn and RtMidiOut definitions. // // **************************************************************** // inline RtMidi::Api RtMidiIn :: getCurrentApi( void ) throw() { return rtapi_->getCurrentApi(); } inline void RtMidiIn :: openPort( unsigned int portNumber, const std::string &portName ) { rtapi_->openPort( portNumber, portName ); } inline void RtMidiIn :: openVirtualPort( const std::string &portName ) { rtapi_->openVirtualPort( portName ); } inline void RtMidiIn :: closePort( void ) { rtapi_->closePort(); } inline bool RtMidiIn :: isPortOpen() const { return rtapi_->isPortOpen(); } inline void RtMidiIn :: setCallback( RtMidiCallback callback, void *userData ) { static_cast(rtapi_)->setCallback( callback, userData ); } inline void RtMidiIn :: cancelCallback( void ) { static_cast(rtapi_)->cancelCallback(); } inline unsigned int RtMidiIn :: getPortCount( void ) { return rtapi_->getPortCount(); } inline std::string RtMidiIn :: getPortName( unsigned int portNumber ) { return rtapi_->getPortName( portNumber ); } inline void RtMidiIn :: ignoreTypes( bool midiSysex, bool midiTime, bool midiSense ) { static_cast(rtapi_)->ignoreTypes( midiSysex, midiTime, midiSense ); } inline double RtMidiIn :: getMessage( std::vector *message ) { return static_cast(rtapi_)->getMessage( message ); } inline void RtMidiIn :: setErrorCallback( RtMidiErrorCallback errorCallback, void *userData ) { rtapi_->setErrorCallback(errorCallback, userData ); } inline RtMidi::Api RtMidiOut :: getCurrentApi( void ) throw() { return rtapi_->getCurrentApi(); } inline void RtMidiOut :: openPort( unsigned int portNumber, const std::string &portName ) { rtapi_->openPort( portNumber, portName ); } inline void RtMidiOut :: openVirtualPort( const std::string &portName ) { rtapi_->openVirtualPort( portName ); } inline void RtMidiOut :: closePort( void ) { rtapi_->closePort(); } inline bool RtMidiOut :: isPortOpen() const { return rtapi_->isPortOpen(); } inline unsigned int RtMidiOut :: getPortCount( void ) { return rtapi_->getPortCount(); } inline std::string RtMidiOut :: getPortName( unsigned int portNumber ) { return rtapi_->getPortName( portNumber ); } inline void RtMidiOut :: sendMessage( const std::vector *message ) { static_cast(rtapi_)->sendMessage( &message->at(0), message->size() ); } inline void RtMidiOut :: sendMessage( const unsigned char *message, size_t size ) { static_cast(rtapi_)->sendMessage( message, size ); } inline void RtMidiOut :: setErrorCallback( RtMidiErrorCallback errorCallback, void *userData ) { rtapi_->setErrorCallback(errorCallback, userData ); } #endif ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1611779482.2534177 python-rtmidi-1.4.7/tests/0000755000175000001440000000000000000000000014524 5ustar00chrisusers././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/tests/test_delete.py0000644000175000001440000000466400000000000017411 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Unit tests for the rtmidi module.""" import gc import unittest import rtmidi class TestDelete(unittest.TestCase): def setUp(self): self.midiout = rtmidi.MidiOut() self.midiin = rtmidi.MidiIn() def test_midiin_delete(self): midiin_ports = self.midiin.get_ports() print("Input ports:") print(midiin_ports) ports_init = self.midiout.get_ports() print("output ports initially:") print(ports_init) if midiin_ports: self.midiin.open_port(0) else: self.midiin.open_virtual_port("My virtual output") ports_before = self.midiout.get_ports() self.assertEqual(len(ports_before), len(ports_init) + 1) print("Output ports BEFORE deleting MidiIn instance:") print(ports_before) self.midiin.delete() ports_after = self.midiout.get_ports() print("Output ports AFTER deleting MidiIn instance:") print(ports_after) self.assertEqual(set(ports_init), set(ports_after)) def test_midiout_delete(self): midiout_ports = self.midiout.get_ports() print("Output ports:") print(midiout_ports) ports_init = self.midiin.get_ports() print("Input ports initially:") print(ports_init) if midiout_ports: self.midiout.open_port(0) else: self.midiout.open_virtual_port("My virtual output") ports_before = self.midiin.get_ports() self.assertEqual(len(ports_before), len(ports_init) + 1) print("Input ports BEFORE deleting MidiOut instance:") print(ports_before) self.midiout.delete() ports_after = self.midiin.get_ports() print("Input ports AFTER deleting MidiOut instance:") print(ports_after) self.assertEqual(set(ports_init), set(ports_after)) def test_double_delete(self): self.assertFalse(self.midiout.is_deleted) self.midiout.delete() self.assertTrue(self.midiout.is_deleted) self.midiout.delete() self.assertTrue(self.midiout.is_deleted) def test_del_after_delete(self): self.midiout.delete() self.assertTrue(self.midiout.is_deleted) self.assertTrue(hasattr(self, 'midiout')) del self.midiout gc.collect() self.assertFalse(hasattr(self, 'midiout')) if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/tests/test_errorcallback.py0000644000175000001440000000406400000000000020747 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Tests for the error callback""" import unittest try: from unittest import mock except ImportError: import mock import rtmidi class TestErrorCallback(unittest.TestCase): INVALID_PORT_NUMBER = 9999 MIDI_OUT_ERROR_USER_DATA = 'midiOutError' MIDI_IN_ERROR_USER_DATA = 'midiInError' def setUp(self): self.midi_out = rtmidi.MidiOut() self.midi_in = rtmidi.MidiIn() def test_default_error_handler(self): with self.assertRaises(rtmidi.InvalidPortError): self.midi_out.open_port(self.INVALID_PORT_NUMBER) def test_midiout_error_callback(self): errcb = mock.Mock() self.midi_out.set_error_callback(errcb, self.MIDI_OUT_ERROR_USER_DATA) self.midi_out.open_port(self.INVALID_PORT_NUMBER) errcb.assert_called_with(rtmidi.ERRORTYPE_INVALID_PARAMETER, mock.ANY, self.MIDI_OUT_ERROR_USER_DATA) def test_midiin_error_callback(self): errcb = mock.Mock() self.midi_in.set_error_callback(errcb, self.MIDI_IN_ERROR_USER_DATA) self.midi_in.open_port(self.INVALID_PORT_NUMBER) errcb.assert_called_with(rtmidi.ERRORTYPE_INVALID_PARAMETER, mock.ANY, self.MIDI_IN_ERROR_USER_DATA) def test_error_callback_without_user_data(self): errcb = mock.Mock() self.midi_out.set_error_callback(errcb) self.midi_out.open_port(self.INVALID_PORT_NUMBER) errcb.assert_called_with(rtmidi.ERRORTYPE_INVALID_PARAMETER, mock.ANY, None) def test_cancel_error_callback(self): errcb = mock.Mock() self.midi_out.set_error_callback(errcb) self.midi_out.cancel_error_callback() try: self.midi_out.open_port(self.INVALID_PORT_NUMBER) except rtmidi.InvalidPortError: pass errcb.assert_not_called() if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/tests/test_errors.py0000644000175000001440000000437300000000000017460 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Tests for the error conditions""" import unittest import rtmidi from rtmidi import InvalidPortError, InvalidUseError class TestErrors(unittest.TestCase): INVALID_PORT_NUMBER = 9999 INVALID_NAME_TYPES = (0, 666, 3.141, object) def setUp(self): self.midi_out = rtmidi.MidiOut() self.midi_in = rtmidi.MidiIn() def test_midiout_invalid_client_name_type(self): for name in self.INVALID_NAME_TYPES: with self.assertRaises(TypeError): rtmidi.MidiOut(rtapi=rtmidi.API_RTMIDI_DUMMY, name=name) def test_midiin_invalid_client_name_type(self): for name in self.INVALID_NAME_TYPES: with self.assertRaises(TypeError): rtmidi.MidiIn(rtapi=rtmidi.API_RTMIDI_DUMMY, name=name) def test_midiout_open_invalid_port(self): with self.assertRaises(InvalidPortError): self.midi_out.open_port(self.INVALID_PORT_NUMBER) def test_midiin_open_invalid_port(self): with self.assertRaises(InvalidPortError): self.midi_in.open_port(self.INVALID_PORT_NUMBER) def test_midiout_open_invalid_port_name_type(self): for name in self.INVALID_NAME_TYPES: with self.assertRaises(TypeError): self.midi_out.open_port(name=name) def test_midiin_open_invalid_port_name_type(self): for name in self.INVALID_NAME_TYPES: with self.assertRaises(TypeError): self.midi_in.open_port(name=name) def test_midiout_double_open_port(self): self.midi_out.open_port() with self.assertRaises(InvalidUseError): self.midi_out.open_port() def test_midiin_double_open_port(self): self.midi_in.open_port() with self.assertRaises(InvalidUseError): self.midi_in.open_port() def test_midiout_double_open_virtual_port(self): self.midi_out.open_virtual_port() with self.assertRaises(InvalidUseError): self.midi_out.open_virtual_port() def test_midiin_double_open_virtual_port(self): self.midi_in.open_virtual_port() with self.assertRaises(InvalidUseError): self.midi_in.open_virtual_port() if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/tests/test_rtmidi.py0000644000175000001440000002205000000000000017424 0ustar00chrisusers#!/usr/bin/env python # -*- coding: utf-8 -*- """Unit tests for the rtmidi module.""" import time import unittest import rtmidi if bytes is str: string_types = (str, unicode) # noqa:F821 else: string_types = (str,) class StaticFunctionsTests(unittest.TestCase): def test_get_api_display_name(self): # Why not 'Unspecified'? self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_LINUX_ALSA), 'ALSA') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_MACOSX_CORE), 'CoreMidi') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_RTMIDI_DUMMY), 'Dummy') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_UNIX_JACK), 'Jack') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_UNSPECIFIED), 'Unknown') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_WINDOWS_MM), 'Windows MultiMedia') def test_get_api_name(self): self.assertEqual(rtmidi.get_api_name(rtmidi.API_LINUX_ALSA), 'alsa') self.assertEqual(rtmidi.get_api_name(rtmidi.API_MACOSX_CORE), 'core') self.assertEqual(rtmidi.get_api_name(rtmidi.API_RTMIDI_DUMMY), 'dummy') self.assertEqual(rtmidi.get_api_name(rtmidi.API_UNIX_JACK), 'jack') self.assertEqual(rtmidi.get_api_name(rtmidi.API_UNSPECIFIED), 'unspecified') self.assertEqual(rtmidi.get_api_name(rtmidi.API_WINDOWS_MM), 'winmm') def test_get_compiled_api(self): apilist = rtmidi.get_compiled_api() self.assertTrue(isinstance(apilist, list)) self.assertTrue(len(apilist) >= 1) for api in apilist: self.assertTrue(api <= rtmidi.API_RTMIDI_DUMMY) def test_get_compiled_api_by_name(self): for api, name in ( (rtmidi.API_LINUX_ALSA, 'alsa'), (rtmidi.API_MACOSX_CORE, 'core'), (rtmidi.API_RTMIDI_DUMMY, 'dummy'), (rtmidi.API_UNIX_JACK, 'jack'), (rtmidi.API_WINDOWS_MM, 'winmm')): res = rtmidi.get_compiled_api_by_name(name) if api in rtmidi.get_compiled_api(): self.assertEqual(res, api) else: self.assertEqual(res, rtmidi.API_UNSPECIFIED) def test_get_rtmidi_version(self): version = rtmidi.get_rtmidi_version() self.assertTrue(isinstance(version, string_types)) self.assertEqual(version, '4.0.0') class BaseTests: NOTE_ON = [0x90, 48, 100] NOTE_OFF = [0x80, 48, 16] IN_CLIENT_NAME = "RtMidiTestCase In" OUT_CLIENT_NAME = "RtMidiTestCase Out" IN_PORT_NAME = 'testin' OUT_PORT_NAME = 'testout' DELAY = 0.1 API = rtmidi.API_UNSPECIFIED def setUp(self): self.midi_in = rtmidi.MidiIn(rtapi=self.API, name=self.IN_CLIENT_NAME) self.midi_out = rtmidi.MidiOut(rtapi=self.API, name=self.OUT_CLIENT_NAME) def tearDown(self): self.midi_in.close_port() del self.midi_in self.midi_out.close_port() del self.midi_out def test_is_port_open(self): assert not self.midi_in.is_port_open() self.midi_in.open_port(0) assert self.midi_in.is_port_open() self.midi_in.close_port() assert not self.midi_in.is_port_open() assert not self.midi_out.is_port_open() self.midi_out.open_port(0) assert self.midi_out.is_port_open() self.midi_out.close_port() assert not self.midi_out.is_port_open() def test_get_current_api(self): assert self.midi_in.get_current_api() == self.API assert self.midi_out.get_current_api() == self.API class VirtualPortsSupportedTests: def test_is_port_open_virtual(self): # virtual ports can't be closed assert not self.midi_in.is_port_open() self.midi_in.open_virtual_port() assert self.midi_in.is_port_open() self.midi_in.close_port() assert self.midi_in.is_port_open() assert not self.midi_out.is_port_open() self.midi_out.open_virtual_port() assert self.midi_out.is_port_open() self.midi_out.close_port() assert self.midi_out.is_port_open() def test_send_and_get_message(self): self.set_up_loopback() self.midi_out.send_message(self.NOTE_ON) self.midi_out.send_message(self.NOTE_OFF) time.sleep(self.DELAY) message_1, _ = self.midi_in.get_message() message_2, _ = self.midi_in.get_message() self.assertEqual(message_1, self.NOTE_ON) self.assertEqual(message_2, self.NOTE_OFF) def test_callback(self): messages = [] def callback(event, data): messages.append((event[0], data)) self.set_up_loopback() self.midi_in.set_callback(callback, data=42) self.midi_out.send_message(self.NOTE_ON) self.midi_out.send_message(self.NOTE_OFF) time.sleep(self.DELAY) self.assertEqual(messages[0], (self.NOTE_ON, 42)) self.assertEqual(messages[1], (self.NOTE_OFF, 42)) self.midi_in.cancel_callback() messages = [] self.midi_out.send_message(self.NOTE_ON) self.midi_out.send_message(self.NOTE_OFF) time.sleep(self.DELAY) self.assertEqual(messages, []) def set_up_loopback(self): # TODO: find better solution than this hack-ish strategy to find out # the port number of the virtual output port, which we have to use, # because for ALSA virtual ports, their name includes the client id. # See: https://github.com/thestk/rtmidi/issues/88 ports_before = self.midi_in.get_ports() self.midi_out.open_virtual_port(name=self.OUT_PORT_NAME) ports_after = self.midi_in.get_ports() self.midi_out_port_name = list(set(ports_after).difference(ports_before))[0] for portnum, port in enumerate(ports_after): if port == self.midi_out_port_name: self.midi_in.open_port(portnum) break else: raise IOError("Could not find MIDI output port.") class VirtualPortsUnsupportedTests: def test_is_port_open_virtual(self): # virtual ports can't be closed assert not self.midi_in.is_port_open() self.assertRaises(NotImplementedError, self.midi_in.open_virtual_port) class SetPortNameSupportedTests: def test_set_port_name_supported(self): self.midi_out.open_virtual_port(name=self.OUT_PORT_NAME) found = False for port in self.midi_in.get_ports(): client, port = port.split(':', 1) if client.startswith(self.OUT_CLIENT_NAME) and port.startswith(self.OUT_PORT_NAME): found = True break assert found self.midi_out.set_port_name("new_port") found = False for port in self.midi_in.get_ports(): client, port = port.split(':', 1) if client.startswith(self.OUT_CLIENT_NAME) and port.startswith("new_port"): found = True break assert found class SetPortNameUnsupportedTests: def test_set_port_name_unsupported(self): self.assertRaises(NotImplementedError, self.midi_out.set_port_name, "new_port") class SetClientNameSupportedTests: def test_set_client_name_supported(self): self.midi_out.open_virtual_port(name=self.OUT_PORT_NAME) found = False for port in self.midi_in.get_ports(): client, port = port.split(':', 1) if client.startswith(self.OUT_CLIENT_NAME) and port.startswith(self.OUT_PORT_NAME): found = True break assert found self.midi_out.set_client_name("new_client") found = False for port in self.midi_in.get_ports(): client, port = port.split(':', 1) if client.startswith("new_client") and port.startswith(self.OUT_PORT_NAME): found = True break assert found class SetClientNameUnsupportedTests: def test_set_client_name_unsupported(self): self.assertRaises(NotImplementedError, self.midi_out.set_client_name, "new_client") if rtmidi.API_LINUX_ALSA in rtmidi.get_compiled_api(): class ALSATestCase(BaseTests, SetPortNameSupportedTests, SetClientNameSupportedTests, VirtualPortsSupportedTests, unittest.TestCase): API = rtmidi.API_LINUX_ALSA if rtmidi.API_UNIX_JACK in rtmidi.get_compiled_api(): class JACKTestCase(BaseTests, SetPortNameSupportedTests, SetClientNameUnsupportedTests, VirtualPortsSupportedTests, unittest.TestCase): API = rtmidi.API_UNIX_JACK if rtmidi.API_MACOSX_CORE in rtmidi.get_compiled_api(): class CoreMIDITestCase(BaseTests, SetPortNameUnsupportedTests, SetClientNameUnsupportedTests, VirtualPortsSupportedTests, unittest.TestCase): API = rtmidi.API_MACOSX_CORE if rtmidi.API_WINDOWS_MM in rtmidi.get_compiled_api(): class WindowsMMTestCase(BaseTests, SetPortNameUnsupportedTests, SetClientNameUnsupportedTests, VirtualPortsUnsupportedTests, unittest.TestCase): API = rtmidi.API_WINDOWS_MM if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/tox.ini0000644000175000001440000000042600000000000014677 0ustar00chrisusers[tox] envlist = flake8, py36, py37, py38, py39 skip_missing_interpreters = True [testenv] commands = py.test -v tests deps = -r{toxinidir}/requirements-dev.txt [testenv:flake8] commands = flake8 setup.py {toxinidir}/rtmidi {toxinidir}/examples {toxinidir}/tests deps = flake8 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1602767366.0 python-rtmidi-1.4.7/update-docs.sh0000755000175000001440000000053200000000000016131 0ustar00chrisusers#!/bin/bash # # update-docs.sh - Build documentation, update gh-pages branch and push changes git checkout master || exit 1 git pull make docs git checkout gh-pages || exit 1 rsync -av docs/_build/html/ . git add -A COMMIT="$(git log -n 1 --pretty=format:"%h" master)" git commit -m "Update docs for commit $COMMIT" git push git checkout master