././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.flake80000644000000000000000000000013614526744666012543 0ustar00[flake8] ignore = E116, E265, E266, E731, W504 max-line-length = 100 exclude = docs,.tox,.git ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.github/workflows/pr_to_master.yml0000644000000000000000000000355714526744666020220 0ustar00name: Build sdist and wheels for testing purposes on: pull_request: branches: - master jobs: build_sdist: name: Build sdist runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 with: submodules: true - name: Install ninja run: pipx install ninja - name: Install alsa deps run: sudo apt-get install libasound2-dev - name: Build sdist run: pipx run build --sdist - name: Check metadata run: pipx run twine check --strict dist/* - name: Upload sdist uses: actions/upload-artifact@v3 with: path: dist/*.tar.gz build_wheels: name: Build wheels on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: true matrix: os: [ubuntu-latest, windows-latest, macos-latest] steps: - uses: actions/checkout@v3 with: submodules: true - uses: ilammy/msvc-dev-cmd@v1 if: matrix.os == 'windows-latest' - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: # Skip trying to test arm64 builds on Intel Macs CIBW_TEST_SKIP: "*-macosx_arm64 *-macosx_universal2:arm64" - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl build_arch_wheels: name: Build wheels on Linux ${{ matrix.arch }} runs-on: ubuntu-20.04 strategy: matrix: arch: [aarch64] steps: - uses: actions/checkout@v3 with: submodules: true - uses: docker/setup-qemu-action@v2 with: platforms: all - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: CIBW_ARCHS: ${{ matrix.arch }} - name: Verify clean directory run: git diff --exit-code shell: bash - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.github/workflows/push_to_master.yml0000644000000000000000000000505314526744666020547 0ustar00name: Build sdist and wheels and publish to TestPyPI on: push: branches: - master jobs: build_sdist: name: Build sdist runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 with: submodules: true - name: Install ninja run: pipx install ninja - name: Install alsa deps run: sudo apt-get install libasound2-dev - name: Build sdist run: pipx run build --sdist - name: Check metadata run: pipx run twine check --strict dist/* - name: Upload sdist uses: actions/upload-artifact@v3 with: path: dist/*.tar.gz build_wheels: name: Build wheels on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: true matrix: os: [ubuntu-latest, windows-latest, macos-latest] steps: - uses: actions/checkout@v3 with: submodules: true - uses: ilammy/msvc-dev-cmd@v1 if: matrix.os == 'windows-latest' - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: # Skip trying to test arm64 builds on Intel Macs CIBW_TEST_SKIP: "*-macosx_arm64 *-macosx_universal2:arm64" - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl build_arch_wheels: name: Build wheels on Linux ${{ matrix.arch }} runs-on: ubuntu-20.04 strategy: matrix: arch: [aarch64] steps: - uses: actions/checkout@v3 with: submodules: true - uses: docker/setup-qemu-action@v2 with: platforms: all - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: CIBW_ARCHS: ${{ matrix.arch }} - name: Verify clean directory run: git diff --exit-code shell: bash - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl upload_pypi: needs: [build_arch_wheels, build_wheels, build_sdist] runs-on: ubuntu-latest environment: PyPI release if: github.ref == 'refs/heads/develop' steps: - uses: actions/download-artifact@v3 with: # unpacks default artifact into dist/ # if `name: artifact` is omitted, the action will create extra parent dir name: artifact path: dist - name: Publish distribution to Test PyPI uses: pypa/gh-action-pypi-publish@v1.8.6 with: skip_existing: true user: __token__ password: ${{ secrets.TEST_PYPI_API_TOKEN }} repository_url: https://test.pypi.org/legacy/ verify-metadata: false ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.github/workflows/release.yml0000644000000000000000000000475314526744666017141 0ustar00name: Build sdist and wheels and publish to PyPI on: release: types: - published workflow_dispatch: permissions: id-token: write # This is required for requesting the JWT jobs: build_sdist: name: Build sdist runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 with: submodules: true - name: Install ninja run: pipx install ninja - name: Install alsa deps run: sudo apt-get install libasound2-dev - name: Build sdist run: pipx run build --sdist - name: Check metadata run: pipx run twine check --strict dist/* - name: Upload sdist uses: actions/upload-artifact@v3 with: path: dist/*.tar.gz build_wheels: name: Build wheels on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, windows-latest, macos-latest] steps: - uses: actions/checkout@v3 with: submodules: true - uses: ilammy/msvc-dev-cmd@v1 if: matrix.os == 'windows-latest' - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: # Skip trying to test arm64 builds on Intel Macs CIBW_TEST_SKIP: "*-macosx_arm64 *-macosx_universal2:arm64" - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl build_arch_wheels: name: Build wheels on Linux ${{ matrix.arch }} runs-on: ubuntu-20.04 strategy: matrix: arch: [aarch64] steps: - uses: actions/checkout@v3 with: submodules: true - uses: docker/setup-qemu-action@v2 with: platforms: all - name: Build wheels uses: pypa/cibuildwheel@v2.16 env: CIBW_ARCHS: ${{ matrix.arch }} - name: Verify clean directory run: git diff --exit-code shell: bash - name: Upload wheels uses: actions/upload-artifact@v3 with: path: wheelhouse/*.whl upload_pypi: needs: [build_arch_wheels, build_wheels, build_sdist] runs-on: ubuntu-latest environment: PyPI release steps: - uses: actions/download-artifact@v3 with: # unpacks default artifact into dist/ # if `name: artifact` is omitted, the action will create extra parent dir name: artifact path: dist - name: Publish distribution to PyPI uses: pypa/gh-action-pypi-publish@v1.8.6 with: user: __token__ password: ${{ secrets.PYPI_API_TOKEN }} verify-metadata: false ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.gitignore0000644000000000000000000000107314526744666013361 0ustar00# Python bytecode *.py[cod] __pycache__ # Cython output src/_rtmidi.cpp # C extensions *.so # Packages *.egg *.egg-info dist/ wheelhouse/ *.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 # docs build artifact rtmidi/version.py # Geany project python-rtmidi.geany ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/.gitmodules0000644000000000000000000000016614526744666013550 0ustar00[submodule "src/rtmidi"] path = src/rtmidi url = https://github.com/SpotlightKid/rtmidi.git branch = python-rtmidi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/AUTHORS.md0000644000000000000000000000044714526744666013044 0ustar00# Credits ## Development Lead - Christopher Arndt ## Release Manager - Bruno Enten ## Contributors - Michiel Overtoom - Orhan Kavrakoğlu - tekHedd - Maurizio Berti - Benoit Pierre - Bruno Enten - Marek Szuba ## Testing - Martin Tarenskeen - Pierre Castellotti ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/CHANGELOG.md0000644000000000000000000006106214526744666013206 0ustar00# Changelog For details and minor changes, please see the [version control log messages](https://github.com/SpotlightKid/python-rtmidi/commits/master). ## 1.5.8 (2023-11-20) Fixes: - Changed CI build configuration, so that auditwheel no longer puts a copy of libasound in the Linux binary wheels - overriding the system libasound - which prevented the `_rtmidi` extension module shared library from being loaded on systems, where the ALSA plugin library path is not `/usr/lib64/alsa-lib`, specifically on Debian-based distros. (#190) - Replace `pip` with `python -m pip` everywhere in in the installation documentation and fixed some minor typos . Changes: - Removed obsolete Python 2 compatibility code in the `_rtmidi` module and references to Python 2 unicode type in its docstrings. ## 1.5.7 (2023-10-24) Project infrastructure: - Enabled CI builds for Python 3.12 (#182). - Updated cibuildwheel version used by CI to 2.16. - Added Python 3.12 to meta-data classifiers in `pyproject.toml`. - Added Python 3.12 to `tox.ini`, removed Python 3.7. - Only use custom meson install script to byte-compile installed Python modules if meson version <= 1.2.0. - Updated latest Python version mentioned in windows install docs. - Updated `requirements-dev.txt` with `pip-compile` (#183). Fixes: - Fixed linting errors in `send_all.py` example (#184). - Fixed (no)gil/except declarations on MIDI in callback and `MidiOut.sendMessage` (#185). The GIL is acquired in any case for MIDI in callback and C++ `sendMessage` call, since Cython needs to check for exceptions. Suppress related Cython compilation performance hints. Also remove wrong statement about the GIL being released in docstring for `send_message`. - Fixed errors and check for empty message correctly when passing an iter- or generator instead of a sequence to `MidiOut.send_message` (#186, #188). ## 1.5.6 (2023-09-12) Fixes: - Fixed building with `meson-python` >= 0.14.0 (#177). ## 1.5.5 (2023-07-26) Fixes: - Fixed Cython compilation errors and warnings (#174). Project infrastructure: - Updated `requirements-dev.txt` with `pip-compile` (#173). - Updated minimum Python version declared in `pyproject.toml` to 3.8. Documentation: - Updated minimum Python version (3.8) stated in readme and docstring. ## 1.5.4 (2023-06-27) Changes: - Added `send_all.py` script to examples (#167). Project infrastructure: - Fixed macOS arm64 binary wheels built by CI without CoreMIDI support (#169). ## 1.5.3 (2023-06-23) Changes: - Updated `rtmidi` submodule (#156). Documentation: - Updated installation documentation (#165). - Updated contributing guide (#165). - Removed Python 3.7 from meta-data classifiers in `pyproject.toml`(dfb3800). Project infrastructure: - Changed the build back-end to meson-python (#161). - Fixed broken macOS arm64 binary wheels built by CI (#161). - Fixed missing JACK backend API support in Linux aarch64 binary wheels built by CI (#161). - Improved tests for binary wheels built by CI (#162). - Cleaned up GitHub actions workflow definitions (#163). - Fixed test coverage report target in Makefile (#164). ## 1.5.2 (2023-06-14) Changes: - Updated `rtmidi` submodule (#156). Project infrastructure: - Updated `requirements-dev.txt` with `pip-compile` (#153). - Changed CI to build separate wheels for both macOS architectures (18bbc74, 20f5cdd). - Improved build dependency selection in meson config (#156). ## 1.5.1 (2023-06-12) Project infrastructure: - Fixed broken windows binary wheels built by CI. ## 1.5.0 (2023-05-23) Fixes: - Fixed memleak in `midiutils.list_{in,out}put_ports` function (#103). - Fixed compilation with PyPy3. Documentation: - Clarified return types in docstrings. - Converted readme, changelog, authors, and install docs to Markdown. Examples: - Fixed `basic/panic.py` to actually use channel number loop var. Project infrastructure: - Modernized project structure and build system (now used `meson` and `mesonpep517`) (#119). - Added working cibuildwheel github action (#121). - Removed redundant Github action (#140). ## 1.4.9 (2021-04-26) Fixes: - Fixed Windows build for 64-bit Python 3.9 on AppVeyor CI. Changes: - The SysEx reception buffer size for the Windows MM backend was changed from 8096 to 8196. - Synced with upstream [RtMidi](https://github.com/thestk/rtmidi) (3dc525baf3cac345cdd3511316571c20b47f30b5, fixes #89). ## 1.4.8 (2021-04-26) Fixes: - Fixed Windows builds on AppVeyor CI. - Fixed command line parsing in `midiclock.py` example script. Changes: - Release GIL in `MidiOut.send_message` so that on backend APIs where this operation is blocking (`WINDOWS_MM`), multiple Python threads using this method on different `MidiOut` instances can run concurently. ## 1.4.7 (2021-01-27) 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. ## 1.4.6 (2020-10-15) 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. ## 1.4.5 (2020-08-26) Fixes: - Revert to old way of reading version number via `exec` (see 8d9a8f9 for background info). ## 1.4.4 (2020-08-26) Fixes: - Fixed `setup.py` to work with Python 2 again, though it is not officially supported anymore (#70, #72). ## 1.4.3 (2020-08-11) 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). ## 1.4.2 (2020-07-18) 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). ## 1.4.1 (2020-04-16) 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). ## 1.4.0 (2020-01-19) 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. ## 1.3.1 (2019-10-15) 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 were 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). ## 1.3.0 (2019-04-15) 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`. ## 1.2.1 (2019-01-18) 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. ## 1.2.0 (2019-01-13) 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. [fork]: https://github.com/SpotlightKid/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. ## 1.1.2 (2018-10-10) 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. ## 1.1.1 (2018-08-06) 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. ## 1.1.0 (2017-04-21) 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 . 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. [RtMidi]: (https://github.com/thestk/rtmidi 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. ## 1.0.0 (2016-11-07) 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`. ## 1.0.0rc1 (2016-10-09) 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. - 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. [osc2midi]: https://github.com/SpotlightKid/osc2rtmidi.git ## 0.5b1 (2014-06-11) Fixes: - Synced [RtMidi] code with git repo @ 2c7a6664d6, which fixed several issues (see ). - `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`. 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! ## 0.4.3b1 (2013-11-10) 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. ## 0.4.2b (2013-11-07) 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\"]{.title-ref}, 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. ## 0.4.1b (2013-11-05) Building: - Include missing `_rtmidi.cpp` file in source distribution. Documentation: - Fill in release data placeholders in `INSTALL.rst`. ## 0.4b (2013-11-05 ) 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. ## 0.3.1a (2013-01-23) Enhancements: - Increase sysex input buffer size for WinMM API again to 8192 (8k) bytes. Requested by Martin Tarenskeen. ## 0.3a (2013-01-14) 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. ## 0.2a (2012-07-22) 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). ## 0.1a (2012-07-13) First public release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/INSTALL-windows.md0000644000000000000000000000744714526744666014524 0ustar00# How to install python-rtmidi from source on Windows These instructions should work for installing `python-rtmidi` from source with Python 3.8+ in the 64-bit or 32-bit versions (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. 1. Install the latest release of Python (3.12 at the time of writing, at least 3.8+) from to the default location (e.g. `C:\Python312`). 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). 2. Install [virtualenv] from a command prompt: ```console 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). 3. Go to 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 1. Open a command line and run: ```console python -m virtualenv rtmidi rtmidi\Scripts\activate ``` 2. Update pip within your virtual environment to the latest version with: ```console (rtmidi)> python -m pip install -U pip ``` 3. Install build dependencies (still in the same command line window): ```console (rtmidi)> python -m pip install build installer ``` ## Download & unpack python-rtmidi source Get the latest python-rtmidi distribution as a Zip archive from and unpack it somewhere. You can do the downloading and unpacking in one step using pip: ```console python -m pip install --no-install -d . "python-rtmidi" ``` Alternatively, clone the python-rtmidi git repository: ```console 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: ```console (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: ```console (rtmidi)> python -m build (rtmidi)> python -m installer dist/*.whl ``` ## Verify your installation Change out of the `python-rtmidi` source directory (important!) and run: ```console (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 [virtualenv]: https://pypi.python.org/pypi/virtualenv ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/INSTALL.md0000644000000000000000000002162614526744666013027 0ustar00# Installation **python-rtmidi** uses a modern [PEP 517] compliant Python build system based on [meson] and [meson-python] 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]: $ python -m pip install python-rtmidi This will download a pre-compiled binary wheel from python-rtmidi's [PyPI page], if available, and install it in your active Python installation. If no fitting binary wheel is available, it will download the source distribution, compile the extension (downloading all the build tools needed in the process) and install it. 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)$ python -m pip install python-rtmidi If you want to pass options to the build process, you need to compile python-rtmidi from source manually. See the [From Source](#from-source) section below for moe information. ## Pre-compiled Binaries Pre-compiled binary wheels of the latest python-rtmidi version for Windows, macOS and Linux are available on PyPI for all supported 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 OS version and processor architecture. * Windows binary wheels are compiled with Windows MultiMedia API support and are available for x86_64 (aka amd64). * macOS / OS X binary wheels are compiled with CoreMIDI support and are available for OS X intel (10.9+) and arm64 (aka M1/M2/Apple silicon, 11.0+). If you need JACK support on OS X, you need to compile python-rtmidi yourself (see the [macOS] section below for details). * Linux binary wheels are available for x64_64 and aarch64 architectures and come with support for ALSA and JACK. They require the `libasound.so.2` library to be installed where the dynamic linker can find it, i.e. somewhere in the standard system library locations, but the come bundled with their own copy of `libjack.so.0` for better compatibility. ## 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 and installation steps consist of the same commands in both cases. ### From the Source Distribution To download the python-rtmidi source distribution archive for the current version and extract it, use the following commands: ```console python -m pip download python-rtmidi tar -xzf python-rtmidi-1.X.Y.tar.gz cd python-rtmidi-1.X.Y ``` Then follow the commands shown in the section [buildinstall]. ### 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. ```console (rtmidi)$ git clone --recursive https://github.com/SpotlightKid/python-rtmidi.git (rtmidi)$ cd python-rtmidi ``` Then follow the commands shown in the section [buildinstall]. (buildinstall)= ### Build and Install #### Using the PEP 517 build method (recommended) The recommended way is to build python-rtmidi via the standard PEP 517 build method and install it only for your current user (which `installer` does by default) or into a virtual environment. If you don't already have the `build` and `installer` Python packages installed, install them with: ```console python -m pip install build installer ``` Then build and install python-rtmidi: ```console python -m build --wheel python -m installer dist/*.whl ``` This will download all the required build tools, install them in a temporary virtual environment, build a wheel, and install it. ### Using meson directly If you can't or don't want to use the standard PEP 517 build method, you can also use meson directly, but then you'll need to make sure all the required build tools are installed. If you are installing from a Git repository checkout, since this does not include the C++ module source code pre-compiled from the Cython source, you'll also need to install Cython >= 0.29, either via pip or from its Git repository. Using virtualenv / virtualenvwrapper is strongly recommended in this scenario: Make a virtual environment: ```console mkvirtualenv rtmidi (rtmidi)$ cdvirtualenv ``` Install meson and ninja and, if neccessary, Cython from PyPI: ```console (rtmidi)$ python -m pip install Cython meson ninja ``` ```console meson setup --prefix=/usr -Dbuildtype=plain builddir meson compile -C builddir meson install -C builddir ``` On Linux or macOS, 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.: ```console sudo meson install -C builddir ``` The `meson setup` command 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 | macOS | Windows | Note | | ------------------ | ----- | ----- | ------- | -------------------------------------------------------- | | `-Dalsa=false` | x | n/a | n/a | Don't compile in support for ALSA backend. | | `-Djack=false` | x | x | n/a | Don't compile in support for JACK backend. | | `-Dcoremidi=false` | n/a | x | n/a | Don't compile in support for CoreMIDI backend. | | `-Dwinmm=false` | n/a | n/a | x | Don't compile in support for Windows MultiMedia backend. | | `-Dverbose=true` | x | x | x | Don't suppress RtMidi warnings to stderr. | | `-Dpython=python3` | x | x | x | Set name (or path) of Python interpreter. | Support for each OS dependent MIDI backend is only enabled when the required library and header files are actually present on the system. (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. 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 `meson.build` script will 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 JACK with the [macOS installer] provided on the JACK web site or build JACK from source. ### Windows Please see the detailed instructions for Windows in `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. [Cython]: http://cython.org/ [macOS installer]: http://jackaudio.org/downloads/ [meson]: https://mesonbuild.com/ [meson-python]: https://github.com/mesonbuild/meson-python [pep 517]: https://peps.python.org/pep-0517/ [pip]: https://pypi.python.org/pypi/pip [PyPI page]: http://python.org/pypi/python-rtmidi#downloads [setuptools]: https://pypi.python.org/pypi/setuptools [user contributed documentation]: https://github.com/SpotlightKid/python-rtmidi/wiki/User-contributed-documentation [virtualenv]: https://pypi.python.org/pypi/virtualenv [virtualenvwrapper]: http://www.doughellmann.com/projects/virtualenvwrapper/ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/LICENSE.md0000644000000000000000000000532314526744666012777 0ustar00Copyright & License =================== python-rtmidi was written by Christopher Arndt, 2012 - 2023. The software is released unter the MIT License: Copyright (c) 2012 - 2023 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=1700514230.0 python_rtmidi-1.5.8/MANIFEST.in0000644000000000000000000000061114526744666013124 0ustar00include Makefile include *.md include requirements-dev.txt include src/_rtmidi.cpp include src/_rtmidi.pyx include src/rtmidi/RtMidi.cpp include src/rtmidi/RtMidi.h include tox.ini exclude .gitignore exclude .gitmodules graft examples graft tests prune .github recursive-exclude * __pycache__ recursive-exclude * *.py[co] recursive-include docs *.md *.rst *.inc conf.py Makefile make.bat ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/Makefile0000644000000000000000000000510714526744666013033 0ustar00.PHONY: clean-pyc clean-build clean coverage docs dist lint release release_upload requirements test BUILDDIR ?= builddir PREFIX ?= /usr/local PYTHON ?= python3 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 "requirements - generate 'requirement-dev.txt' from 'requirements-dev.in'" @echo "test - run tests with pytest" build: $(SOURCES) if [[ -d "$(BUILDDIR)" ]]; then \ meson setup --reconfigure "--prefix=$(PREFIX)" -Dbuildtype=plain $(BUILDDIR); \ else \ meson setup "--prefix=$(PREFIX)" -Dbuildtype=plain $(BUILDDIR); \ fi meson compile -C $(BUILDDIR) check-docs: $(PYTHON) -m pydocstyle rtmidi clean: clean-build clean-docs clean-pyc rm -fr htmlcov/ clean-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: build cp -f $(BUILDDIR)/rtmidi/_rtmidi.*.so rtmidi/ cp -f $(BUILDDIR)/rtmidi/version.py rtmidi/ $(PYTHON) -m coverage run --source rtmidi -m pytest tests $(PYTHON) -m coverage report -m $(PYTHON) -m coverage html -rm -f rtmidi/*.so rtmidi/version.py -xdg-open htmlcov/index.html dist: clean release ls -l dist docs: build cp -f $(BUILDDIR)/rtmidi/_rtmidi.*.so rtmidi/ cp -f $(BUILDDIR)/rtmidi/version.py rtmidi/ rm -f docs/rtmidi.rst rm -f docs/modules.rst sphinx-apidoc -o docs rtmidi cat docs/api.rst.inc >> docs/rtmidi.rst $(MAKE) -C docs clean $(MAKE) -C docs html -rm -f rtmidi/*.so rtmidi/version.py -xdg-open docs/_build/html/index.html lint: $(PYTHON) -m flake8 rtmidi tests examples release: $(PYTHON) -m build release_upload: release $(PYTHON) -m twine upload --skip-existing dist/*.tar.gz dist/*.whl requirements-dev.txt: requirements-dev.in pip-compile --quiet --resolver=backtracking --no-emit-index-url --strip-extras "$<" > "$@" requirements: requirements-dev.txt test: pytest -v tests ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/README.md0000644000000000000000000000536214526744666012655 0ustar00# Welcome to python-rtmidi! A Python binding for the RtMidi C++ library implemented using Cython. [![Latest version](https://shields.io/pypi/v/python-rtmidi)](https://pypi.org/project/python-rtmidi) ![Project status](https://shields.io/pypi/status/python-rtmidi) [![MIT License](https://shields.io/pypi/l/python-rtmidi)](LICENSE.md) ![Python versions](https://shields.io/pypi/pyversions/python-rtmidi) [![Distribution format](https://shields.io/pypi/format/python-rtmidi)](https://pypi.org/project/python-rtmidi/#files) [![CI status](https://github.com/SpotlightKid/python-rtmidi/actions/workflows/push_to_master.yml/badge.svg)](https://github.com/SpotlightKid/python-rtmidi/actions) # 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.8+). The [documentation] provides installation instructions, a history of changes per release and an API reference. See the file [LICENSE.md] about copyright and usage terms. The source code repository and issue tracker are hosted on GitHub: . ## 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: ```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: 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.md]: https://github.com/SpotlightKid/python-rtmidi/blob/master/LICENSE.md [python-rtmidi]: https://github.com/SpotlightKid/python-rtmidi [tests]: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests [RtMidi]: http://www.music.mcgill.ca/~gary/rtmidi/index.html ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/Makefile0000644000000000000000000001517214526744666013766 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/docs/api.rst.inc0000644000000000000000000000136714526744666014402 0ustar00 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=1700514230.0 python_rtmidi-1.5.8/docs/authors.md0000644000000000000000000000003714526744666014327 0ustar00```{include} ../AUTHORS.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/conf.py0000755000000000000000000002051114526744666013621 0ustar00#!/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 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 = {} 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 = ['myst_parser', '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 = ['.md', '.rst'] # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'python-rtmidi' author = 'Christopher Arndt' copyright = f'2012 - 2023, {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' myst_heading_anchors = 3 # -- 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', 'python-rtmidi Documentation', 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', f'{project} Documentation', 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', f'{project} Documentation', author, project, '', '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=1700514230.0 python_rtmidi-1.5.8/docs/contributing.rst0000644000000000000000000000655414526744666015573 0ustar00============ 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 fix 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 -m pip install . 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, make sure that your changes pass the ``flake8`` checks and the unit tests, also testing other Python versions with ``tox``:: $ make lint $ make test ``flake8`` and ``tox`` shoudl have been installed via the requirements file used in the instructions above. Should you use a different setup, make sure you ``pip install`` them into your current Python environment. 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 ``pyproject.toml``) 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=1700514230.0 python_rtmidi-1.5.8/docs/history.md0000644000000000000000000000004114526744666014336 0ustar00```{include} ../CHANGELOG.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/index.rst0000644000000000000000000000040114526744666014154 0ustar00Contents ======== .. toctree:: :maxdepth: 1 readme installation install-windows usage modules contributing authors history license Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/install-windows.md0000644000000000000000000000004714526744666016001 0ustar00```{include} ../INSTALL-windows.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/installation.md0000644000000000000000000000003714526744666015343 0ustar00```{include} ../INSTALL.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/license.md0000644000000000000000000000003714526744666014264 0ustar00```{include} ../LICENSE.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/make.bat0000644000000000000000000001450314526744666013730 0ustar00@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=1700514230.0 python_rtmidi-1.5.8/docs/modules.rst0000644000000000000000000000006714526744666014525 0ustar00rtmidi ====== .. toctree:: :maxdepth: 4 rtmidi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/readme.md0000644000000000000000000000003614526744666014076 0ustar00```{include} ../README.md ``` ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/docs/rtmidi.rst0000644000000000000000000000247114526744666014346 0ustar00rtmidi 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=1700514230.0 python_rtmidi-1.5.8/docs/usage.rst0000644000000000000000000000215114526744666014155 0ustar00======== 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/advanced/ccstore.py0000644000000000000000000000322714526744666016773 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/advanced/midiclock.py0000644000000000000000000000453614526744666017273 0ustar00#!/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 argparse 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): ap = argparse.ArgumentParser(usage=__doc__.splitlines()[0]) ap.add_argument('-p', '--port', help="MIDI input port index / name.") ap.add_argument('bpm', type=int, default=120, help="Starting BPM.") args = ap.parse_args(args) clock = MIDIClockReceiver(args.bpm) try: m_in, port_name = open_midiinput(args.port) 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=1700514230.0 python_rtmidi-1.5.8/examples/advanced/midioutwrapper.py0000644000000000000000000002104514526744666020402 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/advanced/recvrpn.py0000644000000000000000000000503114526744666017003 0ustar00#!/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) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/advanced/send_all.py0000644000000000000000000000472314526744666017114 0ustar00#!/usr/bin/env python3 """Send all notes and CCs with all possible values an all 16 channels.""" import argparse import logging import sys import time from rtmidi.midiutil import open_midioutput from rtmidi.midiconstants import CONTROL_CHANGE, NOTE_OFF, NOTE_ON log = logging.getLogger("midi-send-all") argp = argparse.ArgumentParser() argp.add_argument("-v", "--verbose", action="store_true", help="Verbose output") argp.add_argument( "-c", "--channels", help="Channel or list of channels (comma-separated) to send on (default: 1..16)", ) argp.add_argument( "-d", "--delay", type=float, default=0.01, help="Delay between messages (default: %(default).2f s)", ) argp.add_argument( "-o", "--off-velocity", type=int, default=64, help="Note off velocity (default: %(default)i)" ) argp.add_argument( "-V", "--velocity", type=int, default=127, help="Note on velocity (default: %(default)i)" ) argp.add_argument("port", nargs="?", help="MIDI output port (default: ask)") args = argp.parse_args() logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) if args.channels: channels = [] for ch in args.channels.split(","): try: ch = int(ch.strip()) - 1 if 0 > ch > 16: raise ValueError except (TypeError, ValueError): argp.print_help() sys.exit(1) channels.append(ch) else: channels = range(16) try: midiout, name = open_midioutput() with midiout: for chan in channels: for note in range(128): log.debug( f"Sending NOTE ON: ch={chan+1:02}, note={note:03}, vel={args.velocity:03}" ) midiout.send_message([NOTE_ON | chan, note, args.velocity]) time.sleep(args.delay) log.debug( f"Sending NOTE OFF: ch={chan+1:02}, note={note:03}, vel={args.off_velocity:03}" ) midiout.send_message([NOTE_OFF | chan, note, args.off_velocity]) time.sleep(args.delay) for chan in channels: for cc in range(128): for val in range(128): log.debug(f"Sending CONTROL_CHANGE: ch={chan+1:02}, cc={cc:03}, val={val:03}") midiout.send_message([CONTROL_CHANGE | chan, cc, val]) time.sleep(args.delay) except (EOFError, KeyboardInterrupt): log.warning("Interrupted.") log.debug("Done.") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/basic/contextmanager.py0000644000000000000000000000104114526744666017654 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/basic/midiin_callback.py0000755000000000000000000000251714526744666017736 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/basic/midiin_poll.py0000755000000000000000000000203214526744666017140 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/basic/midiout.py0000755000000000000000000000173714526744666016326 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/basic/noteon2osc.py0000644000000000000000000000176414526744666016742 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/basic/panic.py0000644000000000000000000000137514526744666015741 0ustar00#!/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 | channel, ALL_SOUND_OFF, 0]) midiout.send_message([CONTROL_CHANGE | channel, RESET_ALL_CONTROLLERS, 0]) time.sleep(0.05) time.sleep(0.1) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/basic/probe_ports.py0000755000000000000000000000304314526744666017202 0ustar00#!/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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/README.rst0000644000000000000000000000422314526744666016356 0ustar00Drum 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/break-on-through.txt0000644000000000000000000000042314526744666020602 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/drumseq.py0000755000000000000000000001452514526744666016732 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_01.txt0000644000000000000000000000045714526744666017370 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_02.txt0000644000000000000000000000045714526744666017371 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_03.txt0000644000000000000000000000037714526744666017373 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_04.txt0000644000000000000000000000031614526744666017365 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_05.txt0000644000000000000000000000044614526744666017372 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_06.txt0000644000000000000000000000045714526744666017375 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_07.txt0000644000000000000000000000045614526744666017375 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_08.txt0000644000000000000000000000045614526744666017376 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_09.txt0000644000000000000000000000066214526744666017376 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_10.txt0000644000000000000000000000066314526744666017367 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_11.txt0000644000000000000000000000045314526744666017365 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/example_12.txt0000644000000000000000000000053314526744666017365 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/funkydrummer.txt0000644000000000000000000000023514526744666020157 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/rosanna-shuffle.txt0000644000000000000000000000031514526744666020521 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/drumseq/template.txt0000644000000000000000000000073514526744666017247 0ustar00# 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/midi2command/000-playback.mp30000644000000000000000000013162614526744666020266 0ustar00Infom  #%'*,.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=1700514230.0 python_rtmidi-1.5.8/examples/midi2command/README.rst0000644000000000000000000001277014526744666017247 0ustar00midi2command ============ 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=1700514230.0 python_rtmidi-1.5.8/examples/midi2command/example.cfg0000644000000000000000000000101214526744666017657 0ustar00# 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=1700514230.0 python_rtmidi-1.5.8/examples/midi2command/midi2command.py0000644000000000000000000001573414526744666020500 0ustar00#!/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) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/midifilter/__init__.py0000644000000000000000000000000014526744666017435 0ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/midifilter/__main__.py0000644000000000000000000000712314526744666017433 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/midifilter/filters.py0000644000000000000000000000605714526744666017370 0ustar00# -*- 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=1700514230.0 python_rtmidi-1.5.8/examples/sendsysex.py0000755000000000000000000001232014526744666015606 0ustar00#!/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) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/sequencer/sequencer.py0000644000000000000000000001576314526744666017560 0ustar00#!/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() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/sysex/send_sysex.py0000755000000000000000000000135114526744666017122 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/sysex/send_sysex_file.py0000755000000000000000000000205314526744666020121 0ustar00#!/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 = bytearray(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) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/sysexsaver/__init__.py0000644000000000000000000000000014526744666017521 0ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/examples/sysexsaver/__main__.py0000644000000000000000000001555614526744666017530 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/examples/sysexsaver/manufacturers.csv0000644000000000000000000002634514526744666021030 0ustar00"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=1700514230.0 python_rtmidi-1.5.8/examples/sysexsaver/manufacturers.py0000644000000000000000000003006114526744666020653 0ustar00# -*- 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=1700514230.0 python_rtmidi-1.5.8/examples/sysexsaver/models.py0000644000000000000000000002756314526744666017274 0ustar00# -*- 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=1700514230.0 python_rtmidi-1.5.8/examples/wavetablemodstep.py0000644000000000000000000000625714526744666017140 0ustar00#!/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=1700514230.0 python_rtmidi-1.5.8/meson.build0000644000000000000000000000654214526744666013541 0ustar00project( 'python-rtmidi', 'cpp', version: '1.5.8', license: 'MIT', default_options: [ 'warning_level=2', 'cpp_std=c++11' ], meson_version: '>=0.64.0' ) cpp = meson.get_compiler('cpp') # Jack API (portable) jack2_dep = dependency('jack', version: '>=1.9.11', required: false) jack1_dep = dependency('jack', version: ['>=0.125.0', '<1.0'], required: false) if not jack2_dep.found() and jack1_dep.found() jack_dep = jack1_dep elif jack2_dep.found() jack_dep = jack2_dep else warning('No version of JACK found, which is recent enough (jack2>=1.9.11 or jack1>=0.125.0)') jack_dep = disabler() endif jack_not_found = jack_dep.found() ? false : true ## From https://github.com/numpy/numpy/blob/main/numpy/meson.build # Platform dependent config if host_machine.system().to_lower() == 'windows' # WINDOWS if cpp.get_id() == 'gcc' # For mingw-w64, link statically against the UCRT. gcc_link_args = ['-lucrtbase', '-static'] add_project_link_arguments(gcc_link_args, language: ['c', 'cpp']) # Make fprintf("%zd") work (see https://github.com/rgommers/scipy/issues/118) add_project_arguments('-D__USE_MINGW_ANSI_STDIO=1', language: ['c', 'cpp']) # Manual add of MS_WIN64 macro when not using MSVC. # https://bugs.python.org/issue28267 add_project_arguments('-DMS_WIN64', language: ['c', 'cpp']) elif cpp.get_id() == 'msvc' # Force gcc to float64 long doubles for compatibility with MSVC # builds, for C only. add_project_arguments('-mlong-double-64', language: 'c') endif # API winmm_dep = cpp.find_library('winmm', required: jack_not_found) alsa_dep = disabler() elif host_machine.system().to_lower() == 'darwin' # OSX # API coremidi_dep = dependency( 'appleframeworks', modules: ['coreaudio', 'coremidi', 'foundation'], required: jack_not_found ) alsa_dep = disabler() else # LINUX # API alsa_dep = dependency('alsa', required: jack_not_found) endif # Platform detection jack_support = jack_dep.found() and get_option('jack') alsa_support = host_machine.system().to_lower() == 'linux' and alsa_dep.found() and get_option('alsa') coremidi_support = host_machine.system().to_lower() == 'darwin' and coremidi_dep.found() and get_option('coremidi') winmm_support = host_machine.system().to_lower() == 'windows' and winmm_dep.found() and get_option('winmm') threads_dep = dependency('threads', required: alsa_support or jack_support) have_semaphore = cpp.has_header('semaphore.h') pymod = import('python') python = pymod.find_installation(get_option('python'), required: true, pure: false) # Generate _rtmidi extension source subdir('src') # Build & install C++ extension module and Python package subdir('rtmidi') if meson.version().version_compare('<1.2.0') and not get_option('wheel') postinstall_script = files('meson_postinstall.py') meson.add_install_script(python, postinstall_script) endif summary({ 'Host machine system': host_machine.system(), 'Python version': python.language_version(), 'Debug messages (verbose)': get_option('verbose'), 'Build for wheel': get_option('wheel'), 'JACK support': jack_support, 'ALSA support': alsa_support, 'CoreMIDI support': coremidi_support, 'Window MM support': winmm_support, }, section: 'Configuration') ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/meson_options.txt0000644000000000000000000000144114526744666015025 0ustar00option('alsa', type: 'boolean', value: true, description: 'Enable ALSA MIDI support' ) option('coremidi', type: 'boolean', value: true, description: 'Enable CoreMIDI support' ) option('jack', type: 'boolean', value: true, description: 'Enable JACK MIDI support' ) option('python', type: 'string', value: 'python3', description: 'Set name (or path) of Python interpreter' ) option('verbose', type: 'boolean', value: false, description: 'Turn on debug logging (for development)' ) option('wheel', type: 'boolean', value: false, description: 'Turn on build mode for creating a Python wheel (should not be used directly)' ) option('winmm', type: 'boolean', value: true, description: 'Enable Windows MultiMedia support' ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/meson_postinstall.py0000755000000000000000000000071614526744666015526 0ustar00#!/usr/bin/env python3 import sysconfig from compileall import compile_dir from os import environ, path destdir = environ.get('MESON_INSTALL_DESTDIR_PREFIX', '') verbose = environ.get("MESON_INSTALL_QUIET") is None if verbose: print('Compiling Python module to bytecode...') moduledir = sysconfig.get_path('purelib', vars={'base': destdir}) compile_dir(path.join(moduledir, 'rtmidi'), optimize=1, quiet=not verbose, stripdir=destdir or None) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/pyproject.toml0000644000000000000000000000620514526744666014307 0ustar00[build-system] build-backend = "mesonpy" requires = [ "cython", "wheel", "meson-python", "ninja" ] [project] name = "python-rtmidi" dynamic = ['version'] description = "A Python binding for the RtMidi C++ library implemented using Cython." authors = [ { name="Christopher Arndt", email="info@chrisarndt.de" }, ] readme = "README.md" requires-python = ">=3.8" 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.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Multimedia :: Sound/Audio :: MIDI", "Topic :: Software Development :: Libraries :: Python Modules", ] keywords = [ "MIDI", "multimedia", "music", "rtmidi", ] [tool.meson-python.args] setup = [ "-Dwheel=true", "-Dverbose=false", "-Dbuildtype=plain" ] [project.license] file = "LICENSE.md" [project.urls] "Bug Tracker" = "https://github.com/SpotlightKid/python-rtmidi/issues" "Documentation" = "https://spotlightkid.github.io/python-rtmidi/" "Download" = "https://pypi.python.org/pypi/python-rtmidi" "Homepage" = "https://github.com/SpotlightKid/python-rtmidi" "Source" = "https://gitlab.com/SpotlightKid/python-rtmidi/" [tool.black] line-length = 99 target-version = [ "py38", "py39", "py310", "py311", "py312", ] [tool.isort] line_length = 99 profile = "black" [tool.pydocstyle] match = '(?!test_).*\.pyx?' match_dir = '(src|rtmidi)' add_ignore = [ "D412" ] [tool.pytest.ini_options] markers = [ "ci: marks tests to run as part of the CI builds", "jack: marks tests requiring a running JACK server", ] [tool.cibuildwheel] # Switch to using build build-frontend = "build" skip = "pp*" manylinux-x86_64-image = "manylinux_2_28" manylinux-aarch64-image = "manylinux_2_28" # Run the package tests using `pytest` test-requires = "pytest" test-command = "pytest -v -m ci {package}/tests" # Install system library [tool.cibuildwheel.linux] build = "cp3{8,9,10,11,12}-manylinux*" archs = ["auto64"] before-all = [ "dnf -y install alsa-lib-devel alsa-utils", "curl -o jack2-1.9.22.tar.gz https://codeload.github.com/jackaudio/jack2/tar.gz/refs/tags/v1.9.22", "tar -xzf jack2-1.9.22.tar.gz", "cd jack2-1.9.22", "python3 waf configure --prefix=/usr --autostart=none --classic --pkgconfigdir=/usr/lib64/pkgconfig", "python3 waf build", "python3 waf install", ] repair-wheel-command = "auditwheel repair --exclude libasound.so.2 --lib-sdir . -w {dest_dir} {wheel}" [tool.cibuildwheel.macos] build = "cp3{8,9,10,11,12}-macosx*" archs = ["x86_64", "arm64"] [tool.cibuildwheel.windows] build = "cp3{8,9,10,11,12}-win*" archs = ["AMD64"] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/requirements-dev.in0000644000000000000000000000013314526744666015214 0ustar00coverage Cython flake8 myst-parser pip-tools pydocstyle pytest Sphinx sphinx-rtd-theme tox ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/requirements-dev.txt0000644000000000000000000000542614526744666015437 0ustar00# # This file is autogenerated by pip-compile with Python 3.11 # by the following command: # # pip-compile --no-emit-index-url --strip-extras requirements-dev.in # alabaster==0.7.13 # via sphinx babel==2.13.0 # via sphinx build==1.0.3 # via pip-tools cachetools==5.3.1 # via tox certifi==2023.7.22 # via requests chardet==5.2.0 # via tox charset-normalizer==3.3.0 # via requests click==8.1.7 # via pip-tools colorama==0.4.6 # via tox coverage==7.3.2 # via -r requirements-dev.in cython==3.0.4 # via -r requirements-dev.in distlib==0.3.7 # via virtualenv docutils==0.18.1 # via # myst-parser # sphinx # sphinx-rtd-theme filelock==3.12.4 # via # tox # virtualenv flake8==6.1.0 # via -r requirements-dev.in idna==3.4 # via requests imagesize==1.4.1 # via sphinx iniconfig==2.0.0 # via pytest jinja2==3.1.2 # via # myst-parser # sphinx markdown-it-py==3.0.0 # via # mdit-py-plugins # myst-parser markupsafe==2.1.3 # via jinja2 mccabe==0.7.0 # via flake8 mdit-py-plugins==0.4.0 # via myst-parser mdurl==0.1.2 # via markdown-it-py myst-parser==2.0.0 # via -r requirements-dev.in packaging==23.2 # via # build # pyproject-api # pytest # sphinx # tox pip-tools==7.3.0 # via -r requirements-dev.in platformdirs==3.11.0 # via # tox # virtualenv pluggy==1.3.0 # via # pytest # tox pycodestyle==2.11.1 # via flake8 pydocstyle==6.3.0 # via -r requirements-dev.in pyflakes==3.1.0 # via flake8 pygments==2.16.1 # via sphinx pyproject-api==1.6.1 # via tox pyproject-hooks==1.0.0 # via build pytest==7.4.2 # via -r requirements-dev.in pyyaml==6.0.1 # via myst-parser requests==2.31.0 # via sphinx snowballstemmer==2.2.0 # via # pydocstyle # sphinx sphinx==7.2.6 # via # -r requirements-dev.in # myst-parser # sphinx-rtd-theme # sphinxcontrib-applehelp # sphinxcontrib-devhelp # sphinxcontrib-htmlhelp # sphinxcontrib-jquery # sphinxcontrib-qthelp # sphinxcontrib-serializinghtml sphinx-rtd-theme==1.3.0 # via -r requirements-dev.in sphinxcontrib-applehelp==1.0.7 # via sphinx sphinxcontrib-devhelp==1.0.5 # via sphinx sphinxcontrib-htmlhelp==2.0.4 # via sphinx sphinxcontrib-jquery==4.1 # via sphinx-rtd-theme sphinxcontrib-jsmath==1.0.1 # via sphinx sphinxcontrib-qthelp==1.0.6 # via sphinx sphinxcontrib-serializinghtml==1.1.9 # via sphinx tox==4.11.3 # via -r requirements-dev.in urllib3==2.0.7 # via requests virtualenv==20.24.5 # via tox wheel==0.41.2 # via pip-tools # The following packages are considered to be unsafe in a requirements file: # pip # setuptools ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/rtmidi/__init__.py0000644000000000000000000000024514526744666014772 0ustar00"""A binding for the RtMidi C++ library.""" from .version import version as __version__ # noqa from ._rtmidi import * # noqa from ._rtmidi import __doc__ # noqa ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/rtmidi/meson.build0000644000000000000000000000330014526744666015016 0ustar00# https://mesonbuild.com/Python-module.html defines = [] dependencies = [python.dependency()] link_args = [] if coremidi_support defines += ['-D__MACOSX_CORE__'] #defines += ['-frtti'] dependencies += [coremidi_dep] link_args += [ '-framework', 'CoreAudio', '-framework', 'CoreMIDI', '-framework', 'CoreFoundation' ] endif if alsa_support or jack_support dependencies += [threads_dep] endif if alsa_support defines += ['-D__LINUX_ALSA__'] dependencies += [alsa_dep] endif if winmm_support defines += ['-D__WINDOWS_MM__'] if meson.get_compiler('cpp').get_id() != 'gcc' defines += ['/EHsc'] endif dependencies += [winmm_dep] endif if jack_support defines += ['-D__UNIX_JACK__', '-DJACK_HAS_PORT_RENAME'] if have_semaphore defines += ['-DHAVE_SEMAPHORE'] endif dependencies += [jack_dep] endif if get_option('verbose') defines += ['-D__RTMIDI_DEBUG__'] else defines += ['-D__RTMIDI_SILENCE_WARNINGS__'] endif # Build and install the extension module module = python.extension_module( '_rtmidi', [rtmidi_cython, rtmidi_sources], dependencies: dependencies, cpp_args: defines, link_args: link_args, include_directories: rtmidi_inc, install: true, subdir: 'rtmidi', ) # Generate version.py file version_py = configure_file( input: 'version.py.in', output: 'version.py', configuration: { 'VERSION': meson.project_version() } ) # Pure Python sources python_sources = files([ '__init__.py', 'midiconstants.py', 'midiutil.py', ]) # Install pure Python modules python.install_sources( python_sources, version_py, subdir: 'rtmidi', ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/rtmidi/midiconstants.py0000644000000000000000000001655514526744666016125 0ustar00# -*- 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=1700514230.0 python_rtmidi-1.5.8/rtmidi/midiutil.py0000644000000000000000000002205514526744666015056 0ustar00# -*- 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) midiin.delete() 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) midiout.delete() 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 in-/output and return MidiIn/-Out instance and port name. 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 and port name. See the ``open_midiport`` function for information on parameters, return types 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 and port name. See the ``open_midiport`` function for information on parameters, return types and possible exceptions. """ return open_midiport(port, "output", api, use_virtual, interactive, client_name, port_name) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/rtmidi/version.py.in0000644000000000000000000000003614526744666015323 0ustar00version = "@VERSION@" # noqa ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1700516159.3869593 python_rtmidi-1.5.8/src/_rtmidi.cpp0000644000175100001770000403754014526750477017003 0ustar00runnerdocker/* Generated by Cython 3.0.5 */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #if defined(CYTHON_LIMITED_API) && 0 #ifndef Py_LIMITED_API #if CYTHON_LIMITED_API+0 > 0x03030000 #define Py_LIMITED_API CYTHON_LIMITED_API #else #define Py_LIMITED_API 0x03030000 #endif #endif #endif #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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.7+ or Python 3.3+. #else #if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API #define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else #define __PYX_EXTRA_ABI_MODULE_NAME "" #endif #define CYTHON_ABI "3_0_5" __PYX_EXTRA_ABI_MODULE_NAME #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." #define CYTHON_HEX_VERSION 0x030005F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(_WIN32) && !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 #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX #if defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 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 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PYPY_VERSION) #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #if PY_VERSION_HEX < 0x03090000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_CLINE_IN_TRACEBACK #define CYTHON_CLINE_IN_TRACEBACK 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #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 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 1 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #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 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #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_CPYTHON 1 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef 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 #ifndef 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 || PY_VERSION_HEX >= 0x030B00A2 #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_GIL #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #if PY_VERSION_HEX < 0x030400a1 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #elif !defined(CYTHON_USE_TP_FINALIZE) #define CYTHON_USE_TP_FINALIZE 1 #endif #if PY_VERSION_HEX < 0x030600B1 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if !defined(CYTHON_VECTORCALL) #define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif #define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #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(__cplusplus) /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(maybe_unused) #define CYTHON_UNUSED [[maybe_unused]] #endif #endif #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_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_UNUSED_VAR( const T& ) { } # else # define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #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 short uint16_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; #endif #endif #if _MSC_VER < 1300 #ifdef _WIN64 typedef unsigned long long __pyx_uintptr_t; #else typedef unsigned int __pyx_uintptr_t; #endif #else #ifdef _WIN64 typedef unsigned __int64 __pyx_uintptr_t; #else typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else #include typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #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 #ifdef __cplusplus template struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) #else #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) #else #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #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 ==(const U& other) const { return *ptr == other; } template bool operator !=(const U& other) const { return *ptr != other; } template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } private: T *ptr; }; #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_DefaultClassType PyClass_Type #define __Pyx_PyCode_New(a, p, 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) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *exception_table = NULL; PyObject *types_module=NULL, *code_type=NULL, *result=NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 PyObject *version_info; // borrowed #endif PyObject *py_minor_version = NULL; long minor_version = 0; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 minor_version = 11; // we don't yet need to distinguish between versions > 11 #else if (!(version_info = PySys_GetObject("version_info"))) goto end; if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; minor_version = PyLong_AsLong(py_minor_version); if (minor_version == -1 && PyErr_Occurred()) goto end; #endif if (!(types_module = PyImport_ImportModule("types"))) goto end; if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; if (minor_version <= 7) { (void)p; result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else if (minor_version <= 10) { result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else { if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } end: Py_XDECREF(code_type); Py_XDECREF(exception_table); Py_XDECREF(types_module); Py_XDECREF(py_minor_version); if (type) { PyErr_Restore(type, value, traceback); } return result; } #ifndef CO_OPTIMIZED #define CO_OPTIMIZED 0x0001 #endif #ifndef CO_NEWLOCALS #define CO_NEWLOCALS 0x0002 #endif #ifndef CO_VARARGS #define CO_VARARGS 0x0004 #endif #ifndef CO_VARKEYWORDS #define CO_VARKEYWORDS 0x0008 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x0200 #endif #ifndef CO_GENERATOR #define CO_GENERATOR 0x0020 #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x0080 #endif #elif PY_VERSION_HEX >= 0x030B0000 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyCodeObject *result; PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); // we don't have access to __pyx_empty_bytes here if (!empty_bytes) return NULL; result = #if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs #else PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); Py_DECREF(empty_bytes); return result; } #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_PyCode_New(a, p, 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 #endif #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) #else #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) #define __Pyx_Py_Is(x, y) Py_Is(x, y) #else #define __Pyx_Py_Is(x, y) ((x) == (y)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) #else #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) #else #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) #else #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif #define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x200 #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 Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE 0 #endif #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING 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_METH_FASTCALL #define __Pyx_METH_FASTCALL METH_FASTCALL #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords #else #define __Pyx_METH_FASTCALL METH_VARARGS #define __Pyx_PyCFunction_FastCall PyCFunction #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords #endif #if CYTHON_VECTORCALL #define __pyx_vectorcallfunc vectorcallfunc #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) #elif CYTHON_BACKPORT_VECTORCALL typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames); #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #if PY_MAJOR_VERSION >= 0x030900B1 #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if __PYX_LIMITED_VERSION_HEX < 0x030900B1 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #define __Pyx_PyCMethod PyCMethod #endif #ifndef METH_METHOD #define METH_METHOD 0x200 #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_LIMITED_API #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_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_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #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 CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #endif #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) #else #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #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 PY_MAJOR_VERSION < 3 #if CYTHON_COMPILING_IN_PYPY #if PYPY_VERSION_NUM < 0x07030600 #if defined(__cplusplus) && __cplusplus >= 201402L [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] #elif defined(__GNUC__) || defined(__clang__) __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) #elif defined(_MSC_VER) __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) #endif static CYTHON_INLINE int PyGILState_Check(void) { return 0; } #else // PYPY_VERSION_NUM < 0x07030600 #endif // PYPY_VERSION_NUM < 0x07030600 #else static CYTHON_INLINE int PyGILState_Check(void) { PyThreadState * tstate = _PyThreadState_Current; return tstate && (tstate == PyGILState_GetThisThreadState()); } #endif #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || 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 > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL) PyErr_Clear(); return res; } #elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ PyTypeObject *type = Py_TYPE(obj);\ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ PyObject_GC_Del(obj);\ Py_DECREF(type);\ } #else #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #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) ((int)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, (Py_UCS4) ch) #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #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) ? 65535U : 1114111U) #define __Pyx_PyUnicode_KIND(u) ((int)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] = (Py_UNICODE) 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 #if !defined(PyUnicode_DecodeUnicodeEscape) #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) #endif #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) #undef PyUnicode_Contains #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #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 #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) __Pyx_IS_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_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #endif #if PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #else static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { PyObject *module = PyImport_AddModule(name); Py_XINCREF(module); return module; } #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) #define __Pyx_Py3Int_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 #else #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #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 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(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #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; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #define __PYX_EXTERN_C extern "C++" #endif #define __PYX_HAVE___rtmidi #define __PYX_HAVE_API___rtmidi /* Early includes */ #include #include #include "ios" #include "new" #include "stdexcept" #include "typeinfo" #include #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 Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #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_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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) #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) { const wchar_t *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else 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); } #endif #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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 #if CYTHON_USE_PYLONG_INTERNALS #if PY_VERSION_HEX >= 0x030C00A7 #ifndef _PyLong_SIGN_MASK #define _PyLong_SIGN_MASK 3 #endif #ifndef _PyLong_NON_SIZE_BITS #define _PyLong_NON_SIZE_BITS 3 #endif #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_SignedDigitCount(x)\ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) #else #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else // Py < 3.12 #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) #define __Pyx_PyLong_CompactValue(x)\ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) typedef sdigit __Pyx_compact_pylong; typedef digit __Pyx_compact_upylong; #endif #if PY_VERSION_HEX >= 0x030C00A5 #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) #else #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) #endif #endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #include 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] = (char) 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 #include 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; } #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; /* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "_rtmidi.pyx", "", }; /* #### Code section: utility_code_proto_before_types ### */ /* 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() /* #### Code section: numeric_typedefs ### */ /* #### Code section: complex_type_declarations ### */ /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_7_rtmidi_MidiBase; struct __pyx_obj_7_rtmidi_MidiIn; struct __pyx_obj_7_rtmidi_MidiOut; /* "_rtmidi.pyx":426 * * * cdef class MidiBase: # <<<<<<<<<<<<<< * cdef object _port * cdef object _error_callback */ struct __pyx_obj_7_rtmidi_MidiBase { PyObject_HEAD struct __pyx_vtabstruct_7_rtmidi_MidiBase *__pyx_vtab; PyObject *_port; PyObject *_error_callback; PyObject *_deleted; }; /* "_rtmidi.pyx":752 * * * cdef class MidiIn(MidiBase): # <<<<<<<<<<<<<< * """Midi input client interface. * */ struct __pyx_obj_7_rtmidi_MidiIn { struct __pyx_obj_7_rtmidi_MidiBase __pyx_base; RtMidiIn *thisptr; PyObject *_callback; }; /* "_rtmidi.pyx":964 * * * cdef class MidiOut(MidiBase): # <<<<<<<<<<<<<< * """Midi output client interface. * */ struct __pyx_obj_7_rtmidi_MidiOut { struct __pyx_obj_7_rtmidi_MidiBase __pyx_base; RtMidiOut *thisptr; }; /* "_rtmidi.pyx":426 * * * cdef class MidiBase: # <<<<<<<<<<<<<< * cdef object _port * cdef object _error_callback */ struct __pyx_vtabstruct_7_rtmidi_MidiBase { RtMidi *(*baseptr)(struct __pyx_obj_7_rtmidi_MidiBase *); }; static struct __pyx_vtabstruct_7_rtmidi_MidiBase *__pyx_vtabptr_7_rtmidi_MidiBase; /* "_rtmidi.pyx":752 * * * cdef class MidiIn(MidiBase): # <<<<<<<<<<<<<< * """Midi input client interface. * */ struct __pyx_vtabstruct_7_rtmidi_MidiIn { struct __pyx_vtabstruct_7_rtmidi_MidiBase __pyx_base; }; static struct __pyx_vtabstruct_7_rtmidi_MidiIn *__pyx_vtabptr_7_rtmidi_MidiIn; /* "_rtmidi.pyx":964 * * * cdef class MidiOut(MidiBase): # <<<<<<<<<<<<<< * """Midi output client interface. * */ struct __pyx_vtabstruct_7_rtmidi_MidiOut { struct __pyx_vtabstruct_7_rtmidi_MidiBase __pyx_base; }; static struct __pyx_vtabstruct_7_rtmidi_MidiOut *__pyx_vtabptr_7_rtmidi_MidiOut; /* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, Py_ssize_t); void (*DECREF)(void*, PyObject*, Py_ssize_t); void (*GOTREF)(void*, PyObject*, Py_ssize_t); void (*GIVEREF)(void*, PyObject*, Py_ssize_t); void* (*SetupContext)(const char*, Py_ssize_t, 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__));\ } #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #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); else {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContextNogil() #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_Py_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; Py_XDECREF(tmp);\ } while (0) #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) /* 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 /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #if PY_VERSION_HEX >= 0x030C00A6 #define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) #else #define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) #endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) #define __Pyx_PyErr_CurrentExceptionType() 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 && PY_VERSION_HEX < 0x030C00A6 #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 /* 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 /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* 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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; #else PyList_SET_ITEM(list, len, x); #endif __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 #if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *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 #if !CYTHON_VECTORCALL #if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets() #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) #else 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 #endif #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 /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectFastCall.proto */ #define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); /* TupleAndListFromArray.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* IncludeStringH.proto */ #include /* 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); /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) #else #define __Pyx_Arg_NewRef_VARARGS(arg) arg // no-op #define __Pyx_Arg_XDECREF_VARARGS(arg) // no-op - arg is borrowed #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_METH_FASTCALL #define __Pyx_Arg_FASTCALL(args, i) args[i] #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 static CYTHON_UNUSED PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif #define __Pyx_Arg_NewRef_FASTCALL(arg) arg // no-op, __Pyx_Arg_FASTCALL is direct and this needs #define __Pyx_Arg_XDECREF_FASTCALL(arg) // no-op - arg was returned from array #else #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) #endif #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS #define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) #else #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); /* 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); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* 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); } /* 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) do {\ 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);\ } while(0) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) 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 /* MoveIfSupported.proto */ #if CYTHON_USE_CPP_STD_MOVE #include #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) #else #define __PYX_STD_MOVE_IF_SUPPORTED(x) x #endif /* 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)); } /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* PyIntCompare.proto */ static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(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); /* JoinPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); /* PyIntCompare.proto */ static CYTHON_INLINE int __Pyx_PyInt_BoolNeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* RaiseUnexpectedTypeError.proto */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE 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 /* 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 /* PyObject_Str.proto */ #define __Pyx_PyObject_Str(obj)\ (likely(PyString_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) /* 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 /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* HasAttr.proto */ #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 #define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) #else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* 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); /* IncludeStructmemberH.proto */ #include /* FixUpExtensionType.proto */ #if CYTHON_USE_TYPE_SPECS static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); #endif /* PyObjectCallNoArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* ValidateBasesTuple.proto */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif /* PyType_Ready.proto */ CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* 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(PyTypeObject* typeptr , void* vtable); /* GetVTable.proto */ static void* __Pyx_GetVtable(PyTypeObject *type); /* MergeVTables.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type); #endif /* SetupReduce.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); #endif /* ImportDottedModule.proto */ static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); #endif /* FetchSharedCythonModule.proto */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* FetchCommonType.proto */ #if !CYTHON_USE_TYPE_SPECS static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); #else static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); #endif /* PyMethodNew.proto */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); typesModule = PyImport_ImportModule("types"); if (!typesModule) return NULL; methodType = PyObject_GetAttrString(typesModule, "MethodType"); Py_DECREF(typesModule); if (!methodType) return NULL; result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); Py_DECREF(methodType); return result; } #elif PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); return PyMethod_New(func, self); } #else #define __Pyx_PyMethod_New PyMethod_New #endif /* PyVectorcallFastCallDict.proto */ #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CYFUNCTION_COROUTINE 0x08 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #else #define __Pyx_CyFunction_GetClassObj(f)\ ((PyObject*) ((PyCMethodObject *) (f))->mm_class) #endif #define __Pyx_CyFunction_SetClassObj(f, classobj)\ __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { #if CYTHON_COMPILING_IN_LIMITED_API PyObject_HEAD PyObject *func; #elif PY_VERSION_HEX < 0x030900B1 PyCFunctionObject func; #else PyCMethodObject func; #endif #if CYTHON_BACKPORT_VECTORCALL __pyx_vectorcallfunc func_vectorcall; #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API 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; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif 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; PyObject *func_is_coroutine; } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check #define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) #define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) #define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); #undef __Pyx_IsSameCFunction #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); 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(PyObject *module); #if CYTHON_METH_FASTCALL static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); #if CYTHON_BACKPORT_VECTORCALL #define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) #else #define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif #endif /* CythonFunction.proto */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); /* Py3UpdateBases.proto */ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); /* CalculateMetaclass.proto */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 #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 /* PyObjectCall2Args.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectLookupSpecial.proto */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) #define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); #else #define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif /* 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 */ #if !CYTHON_COMPILING_IN_LIMITED_API 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); #endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* 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_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); /* 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 *); /* 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); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* FormatTypeName.proto */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) #else typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" #define __Pyx_PyType_GetName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* 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) #define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static unsigned long __Pyx_get_runtime_version(void); static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* #### Code section: module_declarations ### */ static RtMidi *__pyx_f_7_rtmidi_8MidiBase_baseptr(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto*/ static RtMidi *__pyx_f_7_rtmidi_6MidiIn_baseptr(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto*/ static RtMidi *__pyx_f_7_rtmidi_7MidiOut_baseptr(struct __pyx_obj_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" */ static void __pyx_f_7_rtmidi__cb_func(double, std::vector *, void *); /*proto*/ static void __pyx_f_7_rtmidi__cb_error_func(enum RtMidiError::Type, std::string const &, void *); /*proto*/ static PyObject *__pyx_f_7_rtmidi___pyx_unpickle_MidiBase__set_state(struct __pyx_obj_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*/ /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "_rtmidi" extern int __pyx_module_is_main__rtmidi; int __pyx_module_is_main__rtmidi = 0; /* Implementation of "_rtmidi" */ /* #### Code section: global_var ### */ 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; /* #### Code section: string_decls ### */ static const char __pyx_k_c[] = "c"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_p[] = "p"; static const char __pyx_k_s[] = "s"; static const char __pyx_k__9[] = "."; static const char __pyx_k_gc[] = "gc"; static const char __pyx_k__10[] = "*"; static const char __pyx_k__77[] = "?"; 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_exit[] = "__exit__"; 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_spec[] = "__spec__"; 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_enter[] = "__enter__"; static const char __pyx_k_etype[] = "etype"; static const char __pyx_k_inout[] = "inout"; static const char __pyx_k_input[] = "input"; static const char __pyx_k_msg_v[] = "msg_v"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_rtapi[] = "rtapi"; static const char __pyx_k_state[] = "state"; 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_delete[] = "delete"; static const char __pyx_k_dict_2[] = "_dict"; static const char __pyx_k_enable[] = "enable"; 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_rtmidi[] = "_rtmidi"; 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_disable[] = "disable"; static const char __pyx_k_message[] = "message"; 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_exc_info[] = "exc_info"; 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_set_name[] = "__set_name__"; 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_get_ports[] = "get_ports"; static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_open_port[] = "open_port"; 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_delta_time[] = "delta_time"; 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_get_message[] = "get_message"; static const char __pyx_k_mro_entries[] = "__mro_entries__"; static const char __pyx_k_API_WEB_MIDI[] = "API_WEB_MIDI"; 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_ignore_types[] = "ignore_types"; static const char __pyx_k_initializing[] = "_initializing"; static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_is_port_open[] = "is_port_open"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_send_message[] = "send_message"; static const char __pyx_k_set_callback[] = "set_callback"; static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_API_UNIX_JACK[] = "API_UNIX_JACK"; static const char __pyx_k_MidiIn_delete[] = "MidiIn.delete"; 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_init_subclass[] = "__init_subclass__"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_set_port_name[] = "set_port_name"; 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_MidiOut_delete[] = "MidiOut.delete"; static const char __pyx_k_NoDevicesError[] = "NoDevicesError"; static const char __pyx_k_get_port_count[] = "get_port_count"; 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_MidiBase___exit[] = "MidiBase.__exit__"; 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_set_client_name[] = "set_client_name"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_API_RTMIDI_DUMMY[] = "API_RTMIDI_DUMMY"; static const char __pyx_k_InvalidPortError[] = "InvalidPortError"; static const char __pyx_k_MidiBase___enter[] = "MidiBase.__enter__"; 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_MidiIn_close_port[] = "MidiIn.close_port"; static const char __pyx_k_open_virtual_port[] = "open_virtual_port"; static const char __pyx_k_MidiBase_get_ports[] = "MidiBase.get_ports"; static const char __pyx_k_MidiBase_open_port[] = "MidiBase.open_port"; static const char __pyx_k_MidiIn_get_message[] = "MidiIn.get_message"; static const char __pyx_k_RtMidiError___init[] = "RtMidiError.__init__"; static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; 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_MidiBase_close_port[] = "MidiBase.close_port"; static const char __pyx_k_MidiIn_ignore_types[] = "MidiIn.ignore_types"; static const char __pyx_k_MidiIn_set_callback[] = "MidiIn.set_callback"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_event_parsing_error[] = "event parsing error!"; static const char __pyx_k_MidiBase__check_port[] = "MidiBase._check_port"; static const char __pyx_k_MidiOut_send_message[] = "MidiOut.send_message"; 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_MidiBase_is_port_open[] = "MidiBase.is_port_open"; static const char __pyx_k_cancel_error_callback[] = "cancel_error_callback"; 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_MidiBase_get_port_name[] = "MidiBase.get_port_name"; static const char __pyx_k_MidiBase_set_port_name[] = "MidiBase.set_port_name"; static const char __pyx_k_MidiIn___reduce_cython[] = "MidiIn.__reduce_cython__"; static const char __pyx_k_MidiIn_cancel_callback[] = "MidiIn.cancel_callback"; static const char __pyx_k_MidiIn_get_current_api[] = "MidiIn.get_current_api"; 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_MidiBase__decode_string[] = "MidiBase._decode_string"; static const char __pyx_k_MidiBase_get_port_count[] = "MidiBase.get_port_count"; static const char __pyx_k_MidiOut___reduce_cython[] = "MidiOut.__reduce_cython__"; static const char __pyx_k_MidiOut_get_current_api[] = "MidiOut.get_current_api"; static const char __pyx_k_ERRORTYPE_INVALID_DEVICE[] = "ERRORTYPE_INVALID_DEVICE"; static const char __pyx_k_MidiBase___reduce_cython[] = "MidiBase.__reduce_cython__"; static const char __pyx_k_MidiBase_set_client_name[] = "MidiBase.set_client_name"; static const char __pyx_k_MidiIn___setstate_cython[] = "MidiIn.__setstate_cython__"; 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_MidiOut___setstate_cython[] = "MidiOut.__setstate_cython__"; 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_MidiBase___setstate_cython[] = "MidiBase.__setstate_cython__"; static const char __pyx_k_MidiBase_open_virtual_port[] = "MidiBase.open_virtual_port"; static const char __pyx_k_ERRORTYPE_INVALID_PARAMETER[] = "ERRORTYPE_INVALID_PARAMETER"; static const char __pyx_k_MidiBase_set_error_callback[] = "MidiBase.set_error_callback"; static const char __pyx_k_error_looking_for_port_name[] = "error looking for port name!"; static const char __pyx_k_name_must_be_a_bytes_instance[] = "name must be a bytes instance."; static const char __pyx_k_MidiBase_cancel_error_callback[] = "MidiBase.cancel_error_callback"; static const char __pyx_k_home_runner_work_python_rtmidi[] = "/home/runner/work/python-rtmidi/python-rtmidi/src/_rtmidi.pyx"; 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.8+).\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``API_RWEB_MIDI``\n W3C Web MIDI API\n\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 from 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_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 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_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."; /* #### Code section: decls ### */ static PyObject *__pyx_pf_7_rtmidi__to_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_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_7_rtmidi_2get_api_display_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api); /* proto */ static PyObject *__pyx_pf_7_rtmidi_4get_api_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_api); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6get_compiled_api(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8get_compiled_api_by_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7_rtmidi_10get_rtmidi_version(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_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_7_rtmidi_8MidiBase___enter__(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_2__exit__(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_info); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_4_check_port(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_6_decode_string(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_8get_port_count(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_10get_port_name(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_12get_ports(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_encoding); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_14is_port_open(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_16open_port(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, unsigned int __pyx_v_port, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_18open_virtual_port(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_20close_port(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_22set_client_name(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_24set_port_name(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_26set_error_callback(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_28cancel_error_callback(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_30__reduce_cython__(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_8MidiBase_32__setstate_cython__(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7_rtmidi_6MidiIn___cinit__(struct __pyx_obj_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_7_rtmidi_6MidiIn_2get_current_api(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static void __pyx_pf_7_rtmidi_6MidiIn_4__dealloc__(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_6delete(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_10is_deleted___get__(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_8cancel_callback(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_10close_port(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_12get_message(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_14ignore_types(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_sysex, PyObject *__pyx_v_timing, PyObject *__pyx_v_active_sense); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_16set_callback(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_6MidiIn_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7_rtmidi_7MidiOut___cinit__(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self, enum RtMidi::Api __pyx_v_rtapi, PyObject *__pyx_v_name); /* proto */ static void __pyx_pf_7_rtmidi_7MidiOut_2__dealloc__(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_4delete(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_10is_deleted___get__(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_6get_current_api(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_8send_message(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self, PyObject *__pyx_v_message); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7_rtmidi_7MidiOut_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_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_7_rtmidi_MidiBase(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7_rtmidi_MidiIn(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7_rtmidi_MidiOut(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; #ifdef __Pyx_CyFunction_USED PyTypeObject *__pyx_CyFunctionType; #endif #ifdef __Pyx_FusedFunction_USED PyTypeObject *__pyx_FusedFunctionType; #endif #ifdef __Pyx_Generator_USED PyTypeObject *__pyx_GeneratorType; #endif #ifdef __Pyx_IterableCoroutine_USED PyTypeObject *__pyx_IterableCoroutineType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineAwaitType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineType; #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE PyObject *__pyx_type_7_rtmidi_MidiBase; PyObject *__pyx_type_7_rtmidi_MidiIn; PyObject *__pyx_type_7_rtmidi_MidiOut; #endif PyTypeObject *__pyx_ptype_7_rtmidi_MidiBase; PyTypeObject *__pyx_ptype_7_rtmidi_MidiIn; PyTypeObject *__pyx_ptype_7_rtmidi_MidiOut; PyObject *__pyx_n_s_API_LINUX_ALSA; PyObject *__pyx_n_u_API_LINUX_ALSA; PyObject *__pyx_n_s_API_MACOSX_CORE; PyObject *__pyx_n_u_API_MACOSX_CORE; PyObject *__pyx_n_s_API_RTMIDI_DUMMY; PyObject *__pyx_n_u_API_RTMIDI_DUMMY; PyObject *__pyx_n_s_API_UNIX_JACK; PyObject *__pyx_n_u_API_UNIX_JACK; PyObject *__pyx_n_s_API_UNSPECIFIED; PyObject *__pyx_n_u_API_UNSPECIFIED; PyObject *__pyx_n_s_API_WEB_MIDI; PyObject *__pyx_n_u_API_WEB_MIDI; PyObject *__pyx_n_s_API_WINDOWS_MM; PyObject *__pyx_n_u_API_WINDOWS_MM; PyObject *__pyx_kp_u_API_backend_does_not_support_cha; PyObject *__pyx_kp_u_API_backend_does_not_support_cha_2; PyObject *__pyx_kp_s_Base_general_RtMidi_exception_Al; PyObject *__pyx_n_s_ERRORTYPE_DEBUG_WARNING; PyObject *__pyx_n_u_ERRORTYPE_DEBUG_WARNING; PyObject *__pyx_n_s_ERRORTYPE_DRIVER_ERROR; PyObject *__pyx_n_u_ERRORTYPE_DRIVER_ERROR; PyObject *__pyx_n_s_ERRORTYPE_INVALID_DEVICE; PyObject *__pyx_n_u_ERRORTYPE_INVALID_DEVICE; PyObject *__pyx_n_s_ERRORTYPE_INVALID_PARAMETER; PyObject *__pyx_n_u_ERRORTYPE_INVALID_PARAMETER; PyObject *__pyx_n_s_ERRORTYPE_INVALID_USE; PyObject *__pyx_n_u_ERRORTYPE_INVALID_USE; PyObject *__pyx_n_s_ERRORTYPE_MEMORY_ERROR; PyObject *__pyx_n_u_ERRORTYPE_MEMORY_ERROR; PyObject *__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND; PyObject *__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND; PyObject *__pyx_n_s_ERRORTYPE_SYSTEM_ERROR; PyObject *__pyx_n_u_ERRORTYPE_SYSTEM_ERROR; PyObject *__pyx_n_s_ERRORTYPE_THREAD_ERROR; PyObject *__pyx_n_u_ERRORTYPE_THREAD_ERROR; PyObject *__pyx_n_s_ERRORTYPE_UNSPECIFIED; PyObject *__pyx_n_u_ERRORTYPE_UNSPECIFIED; PyObject *__pyx_n_s_ERRORTYPE_WARNING; PyObject *__pyx_n_u_ERRORTYPE_WARNING; PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; PyObject *__pyx_n_s_InvalidPortError; PyObject *__pyx_n_u_InvalidPortError; PyObject *__pyx_n_s_InvalidUseError; PyObject *__pyx_n_u_InvalidUseError; PyObject *__pyx_kp_u_JACK_server_not_running; PyObject *__pyx_n_s_MemoryAllocationError; PyObject *__pyx_n_u_MemoryAllocationError; PyObject *__pyx_n_s_MemoryError; PyObject *__pyx_n_s_MidiBase; PyObject *__pyx_n_s_MidiBase___enter; PyObject *__pyx_n_s_MidiBase___exit; PyObject *__pyx_n_s_MidiBase___reduce_cython; PyObject *__pyx_n_s_MidiBase___setstate_cython; PyObject *__pyx_n_s_MidiBase__check_port; PyObject *__pyx_n_s_MidiBase__decode_string; PyObject *__pyx_n_s_MidiBase_cancel_error_callback; PyObject *__pyx_n_s_MidiBase_close_port; PyObject *__pyx_n_s_MidiBase_get_port_count; PyObject *__pyx_n_s_MidiBase_get_port_name; PyObject *__pyx_n_s_MidiBase_get_ports; PyObject *__pyx_n_s_MidiBase_is_port_open; PyObject *__pyx_n_s_MidiBase_open_port; PyObject *__pyx_n_s_MidiBase_open_virtual_port; PyObject *__pyx_n_s_MidiBase_set_client_name; PyObject *__pyx_n_s_MidiBase_set_error_callback; PyObject *__pyx_n_s_MidiBase_set_port_name; PyObject *__pyx_n_s_MidiIn; PyObject *__pyx_n_u_MidiIn; PyObject *__pyx_n_s_MidiIn___reduce_cython; PyObject *__pyx_n_s_MidiIn___setstate_cython; PyObject *__pyx_n_s_MidiIn_cancel_callback; PyObject *__pyx_n_s_MidiIn_close_port; PyObject *__pyx_n_s_MidiIn_delete; PyObject *__pyx_n_s_MidiIn_get_current_api; PyObject *__pyx_n_s_MidiIn_get_message; PyObject *__pyx_n_s_MidiIn_ignore_types; PyObject *__pyx_n_s_MidiIn_set_callback; PyObject *__pyx_n_s_MidiOut; PyObject *__pyx_n_u_MidiOut; PyObject *__pyx_n_s_MidiOut___reduce_cython; PyObject *__pyx_n_s_MidiOut___setstate_cython; PyObject *__pyx_n_s_MidiOut_delete; PyObject *__pyx_n_s_MidiOut_get_current_api; PyObject *__pyx_n_s_MidiOut_send_message; PyObject *__pyx_n_s_NoDevicesError; PyObject *__pyx_n_u_NoDevicesError; PyObject *__pyx_kp_u_No_port_currently_opened; PyObject *__pyx_kp_u_None; PyObject *__pyx_n_s_NotImplementedError; PyObject *__pyx_n_s_OSError; PyObject *__pyx_n_s_PickleError; PyObject *__pyx_kp_s_Raised_if_a_memory_allocation_fa; PyObject *__pyx_kp_s_Raised_if_a_method_is_not_suppor; PyObject *__pyx_kp_s_Raised_if_an_error_happened_at_t; PyObject *__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo; PyObject *__pyx_kp_s_Raised_when_an_invalid_port_numb; PyObject *__pyx_kp_s_Raised_when_an_method_call_is_no; PyObject *__pyx_n_s_RtMidiError; PyObject *__pyx_n_u_RtMidiError; PyObject *__pyx_n_s_RtMidiError___init; PyObject *__pyx_kp_u_RtMidiIn_Client; PyObject *__pyx_kp_u_RtMidiOut_Client; PyObject *__pyx_kp_u_RtMidi_s; PyObject *__pyx_kp_u_RtMidi_virtual_s; PyObject *__pyx_n_s_RuntimeError; PyObject *__pyx_n_s_SystemError; PyObject *__pyx_n_u_SystemError; PyObject *__pyx_n_s_TypeError; PyObject *__pyx_n_s_UnsupportedOperationError; PyObject *__pyx_n_u_UnsupportedOperationError; PyObject *__pyx_n_s_ValueError; PyObject *__pyx_kp_u_Virtual_ports_are_not_supported; PyObject *__pyx_n_s__10; PyObject *__pyx_n_s__77; PyObject *__pyx_kp_u__9; PyObject *__pyx_n_s_active_sense; PyObject *__pyx_n_s_all; PyObject *__pyx_kp_u_already_opened_virtual; PyObject *__pyx_n_s_api; PyObject *__pyx_n_s_api_v; PyObject *__pyx_n_s_asyncio_coroutines; PyObject *__pyx_n_u_auto; PyObject *__pyx_n_s_c; PyObject *__pyx_n_s_cancel_callback; PyObject *__pyx_n_s_cancel_error_callback; PyObject *__pyx_n_s_check_port; PyObject *__pyx_n_s_cline_in_traceback; PyObject *__pyx_n_s_close_port; PyObject *__pyx_n_u_darwin; PyObject *__pyx_n_s_data; PyObject *__pyx_n_s_decode; PyObject *__pyx_n_s_decode_string; PyObject *__pyx_n_s_default_error_handler; PyObject *__pyx_n_s_delete; PyObject *__pyx_n_s_delta_time; PyObject *__pyx_n_s_dict; PyObject *__pyx_n_s_dict_2; PyObject *__pyx_kp_u_disable; PyObject *__pyx_n_s_doc; PyObject *__pyx_kp_u_enable; PyObject *__pyx_n_s_encoding; PyObject *__pyx_n_s_endswith; PyObject *__pyx_n_s_enter; PyObject *__pyx_kp_u_error_looking_for_port_name; PyObject *__pyx_kp_u_error_sending_MIDI_message_to_po; PyObject *__pyx_kp_u_error_sending_MIDI_to_virtual_de; PyObject *__pyx_n_s_etype; PyObject *__pyx_kp_u_event_parsing_error; PyObject *__pyx_n_s_exc_info; PyObject *__pyx_n_s_exit; PyObject *__pyx_n_s_func; PyObject *__pyx_kp_u_gc; PyObject *__pyx_n_s_get_api_display_name; PyObject *__pyx_n_u_get_api_display_name; PyObject *__pyx_n_s_get_api_name; PyObject *__pyx_n_u_get_api_name; PyObject *__pyx_n_s_get_compiled_api; PyObject *__pyx_n_u_get_compiled_api; PyObject *__pyx_n_s_get_compiled_api_by_name; PyObject *__pyx_n_u_get_compiled_api_by_name; PyObject *__pyx_n_s_get_current_api; PyObject *__pyx_n_s_get_message; PyObject *__pyx_n_s_get_port_count; PyObject *__pyx_n_s_get_port_name; PyObject *__pyx_n_s_get_ports; PyObject *__pyx_n_s_get_rtmidi_version; PyObject *__pyx_n_u_get_rtmidi_version; PyObject *__pyx_n_s_getstate; PyObject *__pyx_kp_s_home_runner_work_python_rtmidi; PyObject *__pyx_n_s_i; PyObject *__pyx_n_u_ignore; PyObject *__pyx_n_s_ignore_types; PyObject *__pyx_n_s_import; PyObject *__pyx_n_s_init; PyObject *__pyx_n_s_init_subclass; PyObject *__pyx_n_s_initializing; PyObject *__pyx_n_s_inout; PyObject *__pyx_n_u_input; PyObject *__pyx_n_s_is_coroutine; PyObject *__pyx_kp_u_is_invalid; PyObject *__pyx_n_s_is_port_open; PyObject *__pyx_kp_u_isenabled; PyObject *__pyx_n_u_latin1; PyObject *__pyx_n_u_macroman; PyObject *__pyx_n_s_main; PyObject *__pyx_n_s_message; PyObject *__pyx_kp_u_message_longer_than_3_bytes_but; PyObject *__pyx_kp_u_message_must_not_be_empty; PyObject *__pyx_n_s_metaclass; PyObject *__pyx_n_s_module; PyObject *__pyx_n_s_mro_entries; PyObject *__pyx_n_s_msg; PyObject *__pyx_n_s_msg_v; PyObject *__pyx_n_s_name; PyObject *__pyx_n_s_name_2; PyObject *__pyx_kp_u_name_must_be_a_bytes_instance; PyObject *__pyx_n_s_new; PyObject *__pyx_kp_s_no_default___reduce___due_to_non; PyObject *__pyx_kp_u_no_ports_available; PyObject *__pyx_n_s_open_port; PyObject *__pyx_n_s_open_virtual_port; PyObject *__pyx_n_u_output; PyObject *__pyx_n_s_p; PyObject *__pyx_n_s_pickle; PyObject *__pyx_n_s_platform; PyObject *__pyx_kp_u_port; PyObject *__pyx_n_u_portNumber; PyObject *__pyx_n_s_port_2; PyObject *__pyx_n_s_prepare; PyObject *__pyx_n_s_pyx_PickleError; PyObject *__pyx_n_s_pyx_checksum; PyObject *__pyx_n_s_pyx_result; PyObject *__pyx_n_s_pyx_state; PyObject *__pyx_n_s_pyx_type; PyObject *__pyx_n_s_pyx_unpickle_MidiBase; PyObject *__pyx_n_s_pyx_vtable; PyObject *__pyx_n_s_qualname; PyObject *__pyx_n_s_queue_size_limit; PyObject *__pyx_kp_u_r_already_opened_s_port_i; PyObject *__pyx_n_s_range; PyObject *__pyx_n_s_reduce; PyObject *__pyx_n_s_reduce_cython; PyObject *__pyx_n_s_reduce_ex; PyObject *__pyx_n_s_rtapi; PyObject *__pyx_n_s_rtmidi; PyObject *__pyx_n_s_s; PyObject *__pyx_n_s_self; PyObject *__pyx_n_s_send_message; PyObject *__pyx_n_s_set_callback; PyObject *__pyx_n_s_set_client_name; PyObject *__pyx_n_s_set_error_callback; PyObject *__pyx_n_s_set_name; PyObject *__pyx_n_s_set_port_name; PyObject *__pyx_n_s_setstate; PyObject *__pyx_n_s_setstate_cython; PyObject *__pyx_n_s_spec; PyObject *__pyx_n_s_startswith; PyObject *__pyx_n_s_state; PyObject *__pyx_kp_s_stringsource; PyObject *__pyx_n_s_super; PyObject *__pyx_n_s_sys; PyObject *__pyx_n_s_sysex; PyObject *__pyx_n_s_test; PyObject *__pyx_n_u_thisptr; PyObject *__pyx_n_s_timing; PyObject *__pyx_n_s_to_bytes; PyObject *__pyx_n_s_type; PyObject *__pyx_n_s_update; PyObject *__pyx_n_s_use_setstate; PyObject *__pyx_kp_u_utf_8; PyObject *__pyx_n_s_warn; PyObject *__pyx_n_s_warnings; PyObject *__pyx_n_u_win; PyObject *__pyx_int_0; PyObject *__pyx_int_2218169; PyObject *__pyx_int_34815411; PyObject *__pyx_int_152509455; PyObject *__pyx_int_neg_1; enum RtMidi::Api __pyx_k__4; enum RtMidi::Api __pyx_k__5; PyObject *__pyx_tuple_; PyObject *__pyx_tuple__2; PyObject *__pyx_tuple__3; PyObject *__pyx_tuple__6; PyObject *__pyx_tuple__7; PyObject *__pyx_tuple__8; PyObject *__pyx_tuple__11; PyObject *__pyx_tuple__12; PyObject *__pyx_tuple__14; PyObject *__pyx_tuple__16; PyObject *__pyx_tuple__17; PyObject *__pyx_tuple__20; PyObject *__pyx_tuple__24; PyObject *__pyx_tuple__26; PyObject *__pyx_tuple__28; PyObject *__pyx_tuple__30; PyObject *__pyx_tuple__32; PyObject *__pyx_tuple__34; PyObject *__pyx_tuple__36; PyObject *__pyx_tuple__38; PyObject *__pyx_tuple__41; PyObject *__pyx_tuple__43; PyObject *__pyx_tuple__44; PyObject *__pyx_tuple__47; PyObject *__pyx_tuple__50; PyObject *__pyx_tuple__53; PyObject *__pyx_tuple__55; PyObject *__pyx_tuple__61; PyObject *__pyx_tuple__63; PyObject *__pyx_tuple__65; PyObject *__pyx_tuple__71; PyObject *__pyx_tuple__75; PyObject *__pyx_codeobj__13; PyObject *__pyx_codeobj__15; PyObject *__pyx_codeobj__18; PyObject *__pyx_codeobj__19; PyObject *__pyx_codeobj__21; PyObject *__pyx_codeobj__22; PyObject *__pyx_codeobj__23; PyObject *__pyx_codeobj__25; PyObject *__pyx_codeobj__27; PyObject *__pyx_codeobj__29; PyObject *__pyx_codeobj__31; PyObject *__pyx_codeobj__33; PyObject *__pyx_codeobj__35; PyObject *__pyx_codeobj__37; PyObject *__pyx_codeobj__39; PyObject *__pyx_codeobj__40; PyObject *__pyx_codeobj__42; PyObject *__pyx_codeobj__45; PyObject *__pyx_codeobj__46; PyObject *__pyx_codeobj__48; PyObject *__pyx_codeobj__49; PyObject *__pyx_codeobj__51; PyObject *__pyx_codeobj__52; PyObject *__pyx_codeobj__54; PyObject *__pyx_codeobj__56; PyObject *__pyx_codeobj__57; PyObject *__pyx_codeobj__58; PyObject *__pyx_codeobj__59; PyObject *__pyx_codeobj__60; PyObject *__pyx_codeobj__62; PyObject *__pyx_codeobj__64; PyObject *__pyx_codeobj__66; PyObject *__pyx_codeobj__67; PyObject *__pyx_codeobj__68; PyObject *__pyx_codeobj__69; PyObject *__pyx_codeobj__70; PyObject *__pyx_codeobj__72; PyObject *__pyx_codeobj__73; PyObject *__pyx_codeobj__74; PyObject *__pyx_codeobj__76; } __pyx_mstate; #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) #define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) #define __pyx_m (PyState_FindModule(&__pyx_moduledef)) #else static __pyx_mstate __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; #endif /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_clear(PyObject *m) { __pyx_mstate *clear_module_state = __pyx_mstate(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_CLEAR(clear_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); #endif Py_CLEAR(clear_module_state->__pyx_ptype_7_rtmidi_MidiBase); Py_CLEAR(clear_module_state->__pyx_type_7_rtmidi_MidiBase); Py_CLEAR(clear_module_state->__pyx_ptype_7_rtmidi_MidiIn); Py_CLEAR(clear_module_state->__pyx_type_7_rtmidi_MidiIn); Py_CLEAR(clear_module_state->__pyx_ptype_7_rtmidi_MidiOut); Py_CLEAR(clear_module_state->__pyx_type_7_rtmidi_MidiOut); Py_CLEAR(clear_module_state->__pyx_n_s_API_LINUX_ALSA); Py_CLEAR(clear_module_state->__pyx_n_u_API_LINUX_ALSA); Py_CLEAR(clear_module_state->__pyx_n_s_API_MACOSX_CORE); Py_CLEAR(clear_module_state->__pyx_n_u_API_MACOSX_CORE); Py_CLEAR(clear_module_state->__pyx_n_s_API_RTMIDI_DUMMY); Py_CLEAR(clear_module_state->__pyx_n_u_API_RTMIDI_DUMMY); Py_CLEAR(clear_module_state->__pyx_n_s_API_UNIX_JACK); Py_CLEAR(clear_module_state->__pyx_n_u_API_UNIX_JACK); Py_CLEAR(clear_module_state->__pyx_n_s_API_UNSPECIFIED); Py_CLEAR(clear_module_state->__pyx_n_u_API_UNSPECIFIED); Py_CLEAR(clear_module_state->__pyx_n_s_API_WEB_MIDI); Py_CLEAR(clear_module_state->__pyx_n_u_API_WEB_MIDI); Py_CLEAR(clear_module_state->__pyx_n_s_API_WINDOWS_MM); Py_CLEAR(clear_module_state->__pyx_n_u_API_WINDOWS_MM); Py_CLEAR(clear_module_state->__pyx_kp_u_API_backend_does_not_support_cha); Py_CLEAR(clear_module_state->__pyx_kp_u_API_backend_does_not_support_cha_2); Py_CLEAR(clear_module_state->__pyx_kp_s_Base_general_RtMidi_exception_Al); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_DEBUG_WARNING); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_DEBUG_WARNING); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_DRIVER_ERROR); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_DRIVER_ERROR); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_INVALID_DEVICE); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_INVALID_DEVICE); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_INVALID_PARAMETER); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_INVALID_PARAMETER); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_INVALID_USE); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_INVALID_USE); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_MEMORY_ERROR); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_MEMORY_ERROR); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_SYSTEM_ERROR); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_SYSTEM_ERROR); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_THREAD_ERROR); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_THREAD_ERROR); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_UNSPECIFIED); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_UNSPECIFIED); Py_CLEAR(clear_module_state->__pyx_n_s_ERRORTYPE_WARNING); Py_CLEAR(clear_module_state->__pyx_n_u_ERRORTYPE_WARNING); Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_CLEAR(clear_module_state->__pyx_n_s_InvalidPortError); Py_CLEAR(clear_module_state->__pyx_n_u_InvalidPortError); Py_CLEAR(clear_module_state->__pyx_n_s_InvalidUseError); Py_CLEAR(clear_module_state->__pyx_n_u_InvalidUseError); Py_CLEAR(clear_module_state->__pyx_kp_u_JACK_server_not_running); Py_CLEAR(clear_module_state->__pyx_n_s_MemoryAllocationError); Py_CLEAR(clear_module_state->__pyx_n_u_MemoryAllocationError); Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase___enter); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase___exit); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase__check_port); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase__decode_string); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_cancel_error_callback); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_close_port); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_get_port_count); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_get_port_name); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_get_ports); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_is_port_open); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_open_port); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_open_virtual_port); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_set_client_name); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_set_error_callback); Py_CLEAR(clear_module_state->__pyx_n_s_MidiBase_set_port_name); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn); Py_CLEAR(clear_module_state->__pyx_n_u_MidiIn); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_cancel_callback); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_close_port); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_delete); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_get_current_api); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_get_message); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_ignore_types); Py_CLEAR(clear_module_state->__pyx_n_s_MidiIn_set_callback); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut); Py_CLEAR(clear_module_state->__pyx_n_u_MidiOut); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut_delete); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut_get_current_api); Py_CLEAR(clear_module_state->__pyx_n_s_MidiOut_send_message); Py_CLEAR(clear_module_state->__pyx_n_s_NoDevicesError); Py_CLEAR(clear_module_state->__pyx_n_u_NoDevicesError); Py_CLEAR(clear_module_state->__pyx_kp_u_No_port_currently_opened); Py_CLEAR(clear_module_state->__pyx_kp_u_None); Py_CLEAR(clear_module_state->__pyx_n_s_NotImplementedError); Py_CLEAR(clear_module_state->__pyx_n_s_OSError); Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_if_a_memory_allocation_fa); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_if_a_method_is_not_suppor); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_if_an_error_happened_at_t); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_when_an_invalid_port_numb); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_when_an_method_call_is_no); Py_CLEAR(clear_module_state->__pyx_n_s_RtMidiError); Py_CLEAR(clear_module_state->__pyx_n_u_RtMidiError); Py_CLEAR(clear_module_state->__pyx_n_s_RtMidiError___init); Py_CLEAR(clear_module_state->__pyx_kp_u_RtMidiIn_Client); Py_CLEAR(clear_module_state->__pyx_kp_u_RtMidiOut_Client); Py_CLEAR(clear_module_state->__pyx_kp_u_RtMidi_s); Py_CLEAR(clear_module_state->__pyx_kp_u_RtMidi_virtual_s); Py_CLEAR(clear_module_state->__pyx_n_s_RuntimeError); Py_CLEAR(clear_module_state->__pyx_n_s_SystemError); Py_CLEAR(clear_module_state->__pyx_n_u_SystemError); Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); Py_CLEAR(clear_module_state->__pyx_n_s_UnsupportedOperationError); Py_CLEAR(clear_module_state->__pyx_n_u_UnsupportedOperationError); Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); Py_CLEAR(clear_module_state->__pyx_kp_u_Virtual_ports_are_not_supported); Py_CLEAR(clear_module_state->__pyx_n_s__10); Py_CLEAR(clear_module_state->__pyx_n_s__77); Py_CLEAR(clear_module_state->__pyx_kp_u__9); Py_CLEAR(clear_module_state->__pyx_n_s_active_sense); Py_CLEAR(clear_module_state->__pyx_n_s_all); Py_CLEAR(clear_module_state->__pyx_kp_u_already_opened_virtual); Py_CLEAR(clear_module_state->__pyx_n_s_api); Py_CLEAR(clear_module_state->__pyx_n_s_api_v); Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); Py_CLEAR(clear_module_state->__pyx_n_u_auto); Py_CLEAR(clear_module_state->__pyx_n_s_c); Py_CLEAR(clear_module_state->__pyx_n_s_cancel_callback); Py_CLEAR(clear_module_state->__pyx_n_s_cancel_error_callback); Py_CLEAR(clear_module_state->__pyx_n_s_check_port); Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); Py_CLEAR(clear_module_state->__pyx_n_s_close_port); Py_CLEAR(clear_module_state->__pyx_n_u_darwin); Py_CLEAR(clear_module_state->__pyx_n_s_data); Py_CLEAR(clear_module_state->__pyx_n_s_decode); Py_CLEAR(clear_module_state->__pyx_n_s_decode_string); Py_CLEAR(clear_module_state->__pyx_n_s_default_error_handler); Py_CLEAR(clear_module_state->__pyx_n_s_delete); Py_CLEAR(clear_module_state->__pyx_n_s_delta_time); Py_CLEAR(clear_module_state->__pyx_n_s_dict); Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); Py_CLEAR(clear_module_state->__pyx_kp_u_disable); Py_CLEAR(clear_module_state->__pyx_n_s_doc); Py_CLEAR(clear_module_state->__pyx_kp_u_enable); Py_CLEAR(clear_module_state->__pyx_n_s_encoding); Py_CLEAR(clear_module_state->__pyx_n_s_endswith); Py_CLEAR(clear_module_state->__pyx_n_s_enter); Py_CLEAR(clear_module_state->__pyx_kp_u_error_looking_for_port_name); Py_CLEAR(clear_module_state->__pyx_kp_u_error_sending_MIDI_message_to_po); Py_CLEAR(clear_module_state->__pyx_kp_u_error_sending_MIDI_to_virtual_de); Py_CLEAR(clear_module_state->__pyx_n_s_etype); Py_CLEAR(clear_module_state->__pyx_kp_u_event_parsing_error); Py_CLEAR(clear_module_state->__pyx_n_s_exc_info); Py_CLEAR(clear_module_state->__pyx_n_s_exit); Py_CLEAR(clear_module_state->__pyx_n_s_func); Py_CLEAR(clear_module_state->__pyx_kp_u_gc); Py_CLEAR(clear_module_state->__pyx_n_s_get_api_display_name); Py_CLEAR(clear_module_state->__pyx_n_u_get_api_display_name); Py_CLEAR(clear_module_state->__pyx_n_s_get_api_name); Py_CLEAR(clear_module_state->__pyx_n_u_get_api_name); Py_CLEAR(clear_module_state->__pyx_n_s_get_compiled_api); Py_CLEAR(clear_module_state->__pyx_n_u_get_compiled_api); Py_CLEAR(clear_module_state->__pyx_n_s_get_compiled_api_by_name); Py_CLEAR(clear_module_state->__pyx_n_u_get_compiled_api_by_name); Py_CLEAR(clear_module_state->__pyx_n_s_get_current_api); Py_CLEAR(clear_module_state->__pyx_n_s_get_message); Py_CLEAR(clear_module_state->__pyx_n_s_get_port_count); Py_CLEAR(clear_module_state->__pyx_n_s_get_port_name); Py_CLEAR(clear_module_state->__pyx_n_s_get_ports); Py_CLEAR(clear_module_state->__pyx_n_s_get_rtmidi_version); Py_CLEAR(clear_module_state->__pyx_n_u_get_rtmidi_version); Py_CLEAR(clear_module_state->__pyx_n_s_getstate); Py_CLEAR(clear_module_state->__pyx_kp_s_home_runner_work_python_rtmidi); Py_CLEAR(clear_module_state->__pyx_n_s_i); Py_CLEAR(clear_module_state->__pyx_n_u_ignore); Py_CLEAR(clear_module_state->__pyx_n_s_ignore_types); Py_CLEAR(clear_module_state->__pyx_n_s_import); Py_CLEAR(clear_module_state->__pyx_n_s_init); Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); Py_CLEAR(clear_module_state->__pyx_n_s_initializing); Py_CLEAR(clear_module_state->__pyx_n_s_inout); Py_CLEAR(clear_module_state->__pyx_n_u_input); Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); Py_CLEAR(clear_module_state->__pyx_kp_u_is_invalid); Py_CLEAR(clear_module_state->__pyx_n_s_is_port_open); Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); Py_CLEAR(clear_module_state->__pyx_n_u_latin1); Py_CLEAR(clear_module_state->__pyx_n_u_macroman); Py_CLEAR(clear_module_state->__pyx_n_s_main); Py_CLEAR(clear_module_state->__pyx_n_s_message); Py_CLEAR(clear_module_state->__pyx_kp_u_message_longer_than_3_bytes_but); Py_CLEAR(clear_module_state->__pyx_kp_u_message_must_not_be_empty); Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); Py_CLEAR(clear_module_state->__pyx_n_s_module); Py_CLEAR(clear_module_state->__pyx_n_s_mro_entries); Py_CLEAR(clear_module_state->__pyx_n_s_msg); Py_CLEAR(clear_module_state->__pyx_n_s_msg_v); Py_CLEAR(clear_module_state->__pyx_n_s_name); Py_CLEAR(clear_module_state->__pyx_n_s_name_2); Py_CLEAR(clear_module_state->__pyx_kp_u_name_must_be_a_bytes_instance); Py_CLEAR(clear_module_state->__pyx_n_s_new); Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); Py_CLEAR(clear_module_state->__pyx_kp_u_no_ports_available); Py_CLEAR(clear_module_state->__pyx_n_s_open_port); Py_CLEAR(clear_module_state->__pyx_n_s_open_virtual_port); Py_CLEAR(clear_module_state->__pyx_n_u_output); Py_CLEAR(clear_module_state->__pyx_n_s_p); Py_CLEAR(clear_module_state->__pyx_n_s_pickle); Py_CLEAR(clear_module_state->__pyx_n_s_platform); Py_CLEAR(clear_module_state->__pyx_kp_u_port); Py_CLEAR(clear_module_state->__pyx_n_u_portNumber); Py_CLEAR(clear_module_state->__pyx_n_s_port_2); Py_CLEAR(clear_module_state->__pyx_n_s_prepare); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_MidiBase); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); Py_CLEAR(clear_module_state->__pyx_n_s_qualname); Py_CLEAR(clear_module_state->__pyx_n_s_queue_size_limit); Py_CLEAR(clear_module_state->__pyx_kp_u_r_already_opened_s_port_i); Py_CLEAR(clear_module_state->__pyx_n_s_range); Py_CLEAR(clear_module_state->__pyx_n_s_reduce); Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); Py_CLEAR(clear_module_state->__pyx_n_s_rtapi); Py_CLEAR(clear_module_state->__pyx_n_s_rtmidi); Py_CLEAR(clear_module_state->__pyx_n_s_s); Py_CLEAR(clear_module_state->__pyx_n_s_self); Py_CLEAR(clear_module_state->__pyx_n_s_send_message); Py_CLEAR(clear_module_state->__pyx_n_s_set_callback); Py_CLEAR(clear_module_state->__pyx_n_s_set_client_name); Py_CLEAR(clear_module_state->__pyx_n_s_set_error_callback); Py_CLEAR(clear_module_state->__pyx_n_s_set_name); Py_CLEAR(clear_module_state->__pyx_n_s_set_port_name); Py_CLEAR(clear_module_state->__pyx_n_s_setstate); Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_spec); Py_CLEAR(clear_module_state->__pyx_n_s_startswith); Py_CLEAR(clear_module_state->__pyx_n_s_state); Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); Py_CLEAR(clear_module_state->__pyx_n_s_super); Py_CLEAR(clear_module_state->__pyx_n_s_sys); Py_CLEAR(clear_module_state->__pyx_n_s_sysex); Py_CLEAR(clear_module_state->__pyx_n_s_test); Py_CLEAR(clear_module_state->__pyx_n_u_thisptr); Py_CLEAR(clear_module_state->__pyx_n_s_timing); Py_CLEAR(clear_module_state->__pyx_n_s_to_bytes); Py_CLEAR(clear_module_state->__pyx_n_s_type); Py_CLEAR(clear_module_state->__pyx_n_s_update); Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); Py_CLEAR(clear_module_state->__pyx_kp_u_utf_8); Py_CLEAR(clear_module_state->__pyx_n_s_warn); Py_CLEAR(clear_module_state->__pyx_n_s_warnings); Py_CLEAR(clear_module_state->__pyx_n_u_win); Py_CLEAR(clear_module_state->__pyx_int_0); Py_CLEAR(clear_module_state->__pyx_int_2218169); Py_CLEAR(clear_module_state->__pyx_int_34815411); Py_CLEAR(clear_module_state->__pyx_int_152509455); Py_CLEAR(clear_module_state->__pyx_int_neg_1); Py_CLEAR(clear_module_state->__pyx_tuple_); Py_CLEAR(clear_module_state->__pyx_tuple__2); Py_CLEAR(clear_module_state->__pyx_tuple__3); Py_CLEAR(clear_module_state->__pyx_tuple__6); Py_CLEAR(clear_module_state->__pyx_tuple__7); Py_CLEAR(clear_module_state->__pyx_tuple__8); Py_CLEAR(clear_module_state->__pyx_tuple__11); Py_CLEAR(clear_module_state->__pyx_tuple__12); Py_CLEAR(clear_module_state->__pyx_tuple__14); Py_CLEAR(clear_module_state->__pyx_tuple__16); Py_CLEAR(clear_module_state->__pyx_tuple__17); Py_CLEAR(clear_module_state->__pyx_tuple__20); Py_CLEAR(clear_module_state->__pyx_tuple__24); Py_CLEAR(clear_module_state->__pyx_tuple__26); Py_CLEAR(clear_module_state->__pyx_tuple__28); Py_CLEAR(clear_module_state->__pyx_tuple__30); Py_CLEAR(clear_module_state->__pyx_tuple__32); Py_CLEAR(clear_module_state->__pyx_tuple__34); Py_CLEAR(clear_module_state->__pyx_tuple__36); Py_CLEAR(clear_module_state->__pyx_tuple__38); Py_CLEAR(clear_module_state->__pyx_tuple__41); Py_CLEAR(clear_module_state->__pyx_tuple__43); Py_CLEAR(clear_module_state->__pyx_tuple__44); Py_CLEAR(clear_module_state->__pyx_tuple__47); Py_CLEAR(clear_module_state->__pyx_tuple__50); Py_CLEAR(clear_module_state->__pyx_tuple__53); Py_CLEAR(clear_module_state->__pyx_tuple__55); Py_CLEAR(clear_module_state->__pyx_tuple__61); Py_CLEAR(clear_module_state->__pyx_tuple__63); Py_CLEAR(clear_module_state->__pyx_tuple__65); Py_CLEAR(clear_module_state->__pyx_tuple__71); Py_CLEAR(clear_module_state->__pyx_tuple__75); Py_CLEAR(clear_module_state->__pyx_codeobj__13); Py_CLEAR(clear_module_state->__pyx_codeobj__15); Py_CLEAR(clear_module_state->__pyx_codeobj__18); Py_CLEAR(clear_module_state->__pyx_codeobj__19); Py_CLEAR(clear_module_state->__pyx_codeobj__21); Py_CLEAR(clear_module_state->__pyx_codeobj__22); Py_CLEAR(clear_module_state->__pyx_codeobj__23); Py_CLEAR(clear_module_state->__pyx_codeobj__25); Py_CLEAR(clear_module_state->__pyx_codeobj__27); Py_CLEAR(clear_module_state->__pyx_codeobj__29); Py_CLEAR(clear_module_state->__pyx_codeobj__31); Py_CLEAR(clear_module_state->__pyx_codeobj__33); Py_CLEAR(clear_module_state->__pyx_codeobj__35); Py_CLEAR(clear_module_state->__pyx_codeobj__37); Py_CLEAR(clear_module_state->__pyx_codeobj__39); Py_CLEAR(clear_module_state->__pyx_codeobj__40); Py_CLEAR(clear_module_state->__pyx_codeobj__42); Py_CLEAR(clear_module_state->__pyx_codeobj__45); Py_CLEAR(clear_module_state->__pyx_codeobj__46); Py_CLEAR(clear_module_state->__pyx_codeobj__48); Py_CLEAR(clear_module_state->__pyx_codeobj__49); Py_CLEAR(clear_module_state->__pyx_codeobj__51); Py_CLEAR(clear_module_state->__pyx_codeobj__52); Py_CLEAR(clear_module_state->__pyx_codeobj__54); Py_CLEAR(clear_module_state->__pyx_codeobj__56); Py_CLEAR(clear_module_state->__pyx_codeobj__57); Py_CLEAR(clear_module_state->__pyx_codeobj__58); Py_CLEAR(clear_module_state->__pyx_codeobj__59); Py_CLEAR(clear_module_state->__pyx_codeobj__60); Py_CLEAR(clear_module_state->__pyx_codeobj__62); Py_CLEAR(clear_module_state->__pyx_codeobj__64); Py_CLEAR(clear_module_state->__pyx_codeobj__66); Py_CLEAR(clear_module_state->__pyx_codeobj__67); Py_CLEAR(clear_module_state->__pyx_codeobj__68); Py_CLEAR(clear_module_state->__pyx_codeobj__69); Py_CLEAR(clear_module_state->__pyx_codeobj__70); Py_CLEAR(clear_module_state->__pyx_codeobj__72); Py_CLEAR(clear_module_state->__pyx_codeobj__73); Py_CLEAR(clear_module_state->__pyx_codeobj__74); Py_CLEAR(clear_module_state->__pyx_codeobj__76); return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { __pyx_mstate *traverse_module_state = __pyx_mstate(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); Py_VISIT(traverse_module_state->__pyx_empty_tuple); Py_VISIT(traverse_module_state->__pyx_empty_bytes); Py_VISIT(traverse_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_VISIT(traverse_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); #endif Py_VISIT(traverse_module_state->__pyx_ptype_7_rtmidi_MidiBase); Py_VISIT(traverse_module_state->__pyx_type_7_rtmidi_MidiBase); Py_VISIT(traverse_module_state->__pyx_ptype_7_rtmidi_MidiIn); Py_VISIT(traverse_module_state->__pyx_type_7_rtmidi_MidiIn); Py_VISIT(traverse_module_state->__pyx_ptype_7_rtmidi_MidiOut); Py_VISIT(traverse_module_state->__pyx_type_7_rtmidi_MidiOut); Py_VISIT(traverse_module_state->__pyx_n_s_API_LINUX_ALSA); Py_VISIT(traverse_module_state->__pyx_n_u_API_LINUX_ALSA); Py_VISIT(traverse_module_state->__pyx_n_s_API_MACOSX_CORE); Py_VISIT(traverse_module_state->__pyx_n_u_API_MACOSX_CORE); Py_VISIT(traverse_module_state->__pyx_n_s_API_RTMIDI_DUMMY); Py_VISIT(traverse_module_state->__pyx_n_u_API_RTMIDI_DUMMY); Py_VISIT(traverse_module_state->__pyx_n_s_API_UNIX_JACK); Py_VISIT(traverse_module_state->__pyx_n_u_API_UNIX_JACK); Py_VISIT(traverse_module_state->__pyx_n_s_API_UNSPECIFIED); Py_VISIT(traverse_module_state->__pyx_n_u_API_UNSPECIFIED); Py_VISIT(traverse_module_state->__pyx_n_s_API_WEB_MIDI); Py_VISIT(traverse_module_state->__pyx_n_u_API_WEB_MIDI); Py_VISIT(traverse_module_state->__pyx_n_s_API_WINDOWS_MM); Py_VISIT(traverse_module_state->__pyx_n_u_API_WINDOWS_MM); Py_VISIT(traverse_module_state->__pyx_kp_u_API_backend_does_not_support_cha); Py_VISIT(traverse_module_state->__pyx_kp_u_API_backend_does_not_support_cha_2); Py_VISIT(traverse_module_state->__pyx_kp_s_Base_general_RtMidi_exception_Al); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_DEBUG_WARNING); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_DEBUG_WARNING); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_DRIVER_ERROR); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_DRIVER_ERROR); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_INVALID_DEVICE); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_INVALID_DEVICE); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_INVALID_PARAMETER); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_INVALID_PARAMETER); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_INVALID_USE); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_INVALID_USE); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_MEMORY_ERROR); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_MEMORY_ERROR); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_SYSTEM_ERROR); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_SYSTEM_ERROR); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_THREAD_ERROR); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_THREAD_ERROR); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_UNSPECIFIED); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_UNSPECIFIED); Py_VISIT(traverse_module_state->__pyx_n_s_ERRORTYPE_WARNING); Py_VISIT(traverse_module_state->__pyx_n_u_ERRORTYPE_WARNING); Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_VISIT(traverse_module_state->__pyx_n_s_InvalidPortError); Py_VISIT(traverse_module_state->__pyx_n_u_InvalidPortError); Py_VISIT(traverse_module_state->__pyx_n_s_InvalidUseError); Py_VISIT(traverse_module_state->__pyx_n_u_InvalidUseError); Py_VISIT(traverse_module_state->__pyx_kp_u_JACK_server_not_running); Py_VISIT(traverse_module_state->__pyx_n_s_MemoryAllocationError); Py_VISIT(traverse_module_state->__pyx_n_u_MemoryAllocationError); Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase___enter); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase___exit); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase__check_port); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase__decode_string); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_cancel_error_callback); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_close_port); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_get_port_count); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_get_port_name); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_get_ports); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_is_port_open); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_open_port); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_open_virtual_port); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_set_client_name); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_set_error_callback); Py_VISIT(traverse_module_state->__pyx_n_s_MidiBase_set_port_name); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn); Py_VISIT(traverse_module_state->__pyx_n_u_MidiIn); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_cancel_callback); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_close_port); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_delete); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_get_current_api); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_get_message); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_ignore_types); Py_VISIT(traverse_module_state->__pyx_n_s_MidiIn_set_callback); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut); Py_VISIT(traverse_module_state->__pyx_n_u_MidiOut); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut_delete); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut_get_current_api); Py_VISIT(traverse_module_state->__pyx_n_s_MidiOut_send_message); Py_VISIT(traverse_module_state->__pyx_n_s_NoDevicesError); Py_VISIT(traverse_module_state->__pyx_n_u_NoDevicesError); Py_VISIT(traverse_module_state->__pyx_kp_u_No_port_currently_opened); Py_VISIT(traverse_module_state->__pyx_kp_u_None); Py_VISIT(traverse_module_state->__pyx_n_s_NotImplementedError); Py_VISIT(traverse_module_state->__pyx_n_s_OSError); Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_if_a_memory_allocation_fa); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_if_a_method_is_not_suppor); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_if_an_error_happened_at_t); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_when_an_invalid_port_numb); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_when_an_method_call_is_no); Py_VISIT(traverse_module_state->__pyx_n_s_RtMidiError); Py_VISIT(traverse_module_state->__pyx_n_u_RtMidiError); Py_VISIT(traverse_module_state->__pyx_n_s_RtMidiError___init); Py_VISIT(traverse_module_state->__pyx_kp_u_RtMidiIn_Client); Py_VISIT(traverse_module_state->__pyx_kp_u_RtMidiOut_Client); Py_VISIT(traverse_module_state->__pyx_kp_u_RtMidi_s); Py_VISIT(traverse_module_state->__pyx_kp_u_RtMidi_virtual_s); Py_VISIT(traverse_module_state->__pyx_n_s_RuntimeError); Py_VISIT(traverse_module_state->__pyx_n_s_SystemError); Py_VISIT(traverse_module_state->__pyx_n_u_SystemError); Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); Py_VISIT(traverse_module_state->__pyx_n_s_UnsupportedOperationError); Py_VISIT(traverse_module_state->__pyx_n_u_UnsupportedOperationError); Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); Py_VISIT(traverse_module_state->__pyx_kp_u_Virtual_ports_are_not_supported); Py_VISIT(traverse_module_state->__pyx_n_s__10); Py_VISIT(traverse_module_state->__pyx_n_s__77); Py_VISIT(traverse_module_state->__pyx_kp_u__9); Py_VISIT(traverse_module_state->__pyx_n_s_active_sense); Py_VISIT(traverse_module_state->__pyx_n_s_all); Py_VISIT(traverse_module_state->__pyx_kp_u_already_opened_virtual); Py_VISIT(traverse_module_state->__pyx_n_s_api); Py_VISIT(traverse_module_state->__pyx_n_s_api_v); Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); Py_VISIT(traverse_module_state->__pyx_n_u_auto); Py_VISIT(traverse_module_state->__pyx_n_s_c); Py_VISIT(traverse_module_state->__pyx_n_s_cancel_callback); Py_VISIT(traverse_module_state->__pyx_n_s_cancel_error_callback); Py_VISIT(traverse_module_state->__pyx_n_s_check_port); Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); Py_VISIT(traverse_module_state->__pyx_n_s_close_port); Py_VISIT(traverse_module_state->__pyx_n_u_darwin); Py_VISIT(traverse_module_state->__pyx_n_s_data); Py_VISIT(traverse_module_state->__pyx_n_s_decode); Py_VISIT(traverse_module_state->__pyx_n_s_decode_string); Py_VISIT(traverse_module_state->__pyx_n_s_default_error_handler); Py_VISIT(traverse_module_state->__pyx_n_s_delete); Py_VISIT(traverse_module_state->__pyx_n_s_delta_time); Py_VISIT(traverse_module_state->__pyx_n_s_dict); Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); Py_VISIT(traverse_module_state->__pyx_kp_u_disable); Py_VISIT(traverse_module_state->__pyx_n_s_doc); Py_VISIT(traverse_module_state->__pyx_kp_u_enable); Py_VISIT(traverse_module_state->__pyx_n_s_encoding); Py_VISIT(traverse_module_state->__pyx_n_s_endswith); Py_VISIT(traverse_module_state->__pyx_n_s_enter); Py_VISIT(traverse_module_state->__pyx_kp_u_error_looking_for_port_name); Py_VISIT(traverse_module_state->__pyx_kp_u_error_sending_MIDI_message_to_po); Py_VISIT(traverse_module_state->__pyx_kp_u_error_sending_MIDI_to_virtual_de); Py_VISIT(traverse_module_state->__pyx_n_s_etype); Py_VISIT(traverse_module_state->__pyx_kp_u_event_parsing_error); Py_VISIT(traverse_module_state->__pyx_n_s_exc_info); Py_VISIT(traverse_module_state->__pyx_n_s_exit); Py_VISIT(traverse_module_state->__pyx_n_s_func); Py_VISIT(traverse_module_state->__pyx_kp_u_gc); Py_VISIT(traverse_module_state->__pyx_n_s_get_api_display_name); Py_VISIT(traverse_module_state->__pyx_n_u_get_api_display_name); Py_VISIT(traverse_module_state->__pyx_n_s_get_api_name); Py_VISIT(traverse_module_state->__pyx_n_u_get_api_name); Py_VISIT(traverse_module_state->__pyx_n_s_get_compiled_api); Py_VISIT(traverse_module_state->__pyx_n_u_get_compiled_api); Py_VISIT(traverse_module_state->__pyx_n_s_get_compiled_api_by_name); Py_VISIT(traverse_module_state->__pyx_n_u_get_compiled_api_by_name); Py_VISIT(traverse_module_state->__pyx_n_s_get_current_api); Py_VISIT(traverse_module_state->__pyx_n_s_get_message); Py_VISIT(traverse_module_state->__pyx_n_s_get_port_count); Py_VISIT(traverse_module_state->__pyx_n_s_get_port_name); Py_VISIT(traverse_module_state->__pyx_n_s_get_ports); Py_VISIT(traverse_module_state->__pyx_n_s_get_rtmidi_version); Py_VISIT(traverse_module_state->__pyx_n_u_get_rtmidi_version); Py_VISIT(traverse_module_state->__pyx_n_s_getstate); Py_VISIT(traverse_module_state->__pyx_kp_s_home_runner_work_python_rtmidi); Py_VISIT(traverse_module_state->__pyx_n_s_i); Py_VISIT(traverse_module_state->__pyx_n_u_ignore); Py_VISIT(traverse_module_state->__pyx_n_s_ignore_types); Py_VISIT(traverse_module_state->__pyx_n_s_import); Py_VISIT(traverse_module_state->__pyx_n_s_init); Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); Py_VISIT(traverse_module_state->__pyx_n_s_initializing); Py_VISIT(traverse_module_state->__pyx_n_s_inout); Py_VISIT(traverse_module_state->__pyx_n_u_input); Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); Py_VISIT(traverse_module_state->__pyx_kp_u_is_invalid); Py_VISIT(traverse_module_state->__pyx_n_s_is_port_open); Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); Py_VISIT(traverse_module_state->__pyx_n_u_latin1); Py_VISIT(traverse_module_state->__pyx_n_u_macroman); Py_VISIT(traverse_module_state->__pyx_n_s_main); Py_VISIT(traverse_module_state->__pyx_n_s_message); Py_VISIT(traverse_module_state->__pyx_kp_u_message_longer_than_3_bytes_but); Py_VISIT(traverse_module_state->__pyx_kp_u_message_must_not_be_empty); Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); Py_VISIT(traverse_module_state->__pyx_n_s_module); Py_VISIT(traverse_module_state->__pyx_n_s_mro_entries); Py_VISIT(traverse_module_state->__pyx_n_s_msg); Py_VISIT(traverse_module_state->__pyx_n_s_msg_v); Py_VISIT(traverse_module_state->__pyx_n_s_name); Py_VISIT(traverse_module_state->__pyx_n_s_name_2); Py_VISIT(traverse_module_state->__pyx_kp_u_name_must_be_a_bytes_instance); Py_VISIT(traverse_module_state->__pyx_n_s_new); Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); Py_VISIT(traverse_module_state->__pyx_kp_u_no_ports_available); Py_VISIT(traverse_module_state->__pyx_n_s_open_port); Py_VISIT(traverse_module_state->__pyx_n_s_open_virtual_port); Py_VISIT(traverse_module_state->__pyx_n_u_output); Py_VISIT(traverse_module_state->__pyx_n_s_p); Py_VISIT(traverse_module_state->__pyx_n_s_pickle); Py_VISIT(traverse_module_state->__pyx_n_s_platform); Py_VISIT(traverse_module_state->__pyx_kp_u_port); Py_VISIT(traverse_module_state->__pyx_n_u_portNumber); Py_VISIT(traverse_module_state->__pyx_n_s_port_2); Py_VISIT(traverse_module_state->__pyx_n_s_prepare); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_MidiBase); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); Py_VISIT(traverse_module_state->__pyx_n_s_qualname); Py_VISIT(traverse_module_state->__pyx_n_s_queue_size_limit); Py_VISIT(traverse_module_state->__pyx_kp_u_r_already_opened_s_port_i); Py_VISIT(traverse_module_state->__pyx_n_s_range); Py_VISIT(traverse_module_state->__pyx_n_s_reduce); Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); Py_VISIT(traverse_module_state->__pyx_n_s_rtapi); Py_VISIT(traverse_module_state->__pyx_n_s_rtmidi); Py_VISIT(traverse_module_state->__pyx_n_s_s); Py_VISIT(traverse_module_state->__pyx_n_s_self); Py_VISIT(traverse_module_state->__pyx_n_s_send_message); Py_VISIT(traverse_module_state->__pyx_n_s_set_callback); Py_VISIT(traverse_module_state->__pyx_n_s_set_client_name); Py_VISIT(traverse_module_state->__pyx_n_s_set_error_callback); Py_VISIT(traverse_module_state->__pyx_n_s_set_name); Py_VISIT(traverse_module_state->__pyx_n_s_set_port_name); Py_VISIT(traverse_module_state->__pyx_n_s_setstate); Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_spec); Py_VISIT(traverse_module_state->__pyx_n_s_startswith); Py_VISIT(traverse_module_state->__pyx_n_s_state); Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); Py_VISIT(traverse_module_state->__pyx_n_s_super); Py_VISIT(traverse_module_state->__pyx_n_s_sys); Py_VISIT(traverse_module_state->__pyx_n_s_sysex); Py_VISIT(traverse_module_state->__pyx_n_s_test); Py_VISIT(traverse_module_state->__pyx_n_u_thisptr); Py_VISIT(traverse_module_state->__pyx_n_s_timing); Py_VISIT(traverse_module_state->__pyx_n_s_to_bytes); Py_VISIT(traverse_module_state->__pyx_n_s_type); Py_VISIT(traverse_module_state->__pyx_n_s_update); Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); Py_VISIT(traverse_module_state->__pyx_kp_u_utf_8); Py_VISIT(traverse_module_state->__pyx_n_s_warn); Py_VISIT(traverse_module_state->__pyx_n_s_warnings); Py_VISIT(traverse_module_state->__pyx_n_u_win); Py_VISIT(traverse_module_state->__pyx_int_0); Py_VISIT(traverse_module_state->__pyx_int_2218169); Py_VISIT(traverse_module_state->__pyx_int_34815411); Py_VISIT(traverse_module_state->__pyx_int_152509455); Py_VISIT(traverse_module_state->__pyx_int_neg_1); Py_VISIT(traverse_module_state->__pyx_tuple_); Py_VISIT(traverse_module_state->__pyx_tuple__2); Py_VISIT(traverse_module_state->__pyx_tuple__3); Py_VISIT(traverse_module_state->__pyx_tuple__6); Py_VISIT(traverse_module_state->__pyx_tuple__7); Py_VISIT(traverse_module_state->__pyx_tuple__8); Py_VISIT(traverse_module_state->__pyx_tuple__11); Py_VISIT(traverse_module_state->__pyx_tuple__12); Py_VISIT(traverse_module_state->__pyx_tuple__14); Py_VISIT(traverse_module_state->__pyx_tuple__16); Py_VISIT(traverse_module_state->__pyx_tuple__17); Py_VISIT(traverse_module_state->__pyx_tuple__20); Py_VISIT(traverse_module_state->__pyx_tuple__24); Py_VISIT(traverse_module_state->__pyx_tuple__26); Py_VISIT(traverse_module_state->__pyx_tuple__28); Py_VISIT(traverse_module_state->__pyx_tuple__30); Py_VISIT(traverse_module_state->__pyx_tuple__32); Py_VISIT(traverse_module_state->__pyx_tuple__34); Py_VISIT(traverse_module_state->__pyx_tuple__36); Py_VISIT(traverse_module_state->__pyx_tuple__38); Py_VISIT(traverse_module_state->__pyx_tuple__41); Py_VISIT(traverse_module_state->__pyx_tuple__43); Py_VISIT(traverse_module_state->__pyx_tuple__44); Py_VISIT(traverse_module_state->__pyx_tuple__47); Py_VISIT(traverse_module_state->__pyx_tuple__50); Py_VISIT(traverse_module_state->__pyx_tuple__53); Py_VISIT(traverse_module_state->__pyx_tuple__55); Py_VISIT(traverse_module_state->__pyx_tuple__61); Py_VISIT(traverse_module_state->__pyx_tuple__63); Py_VISIT(traverse_module_state->__pyx_tuple__65); Py_VISIT(traverse_module_state->__pyx_tuple__71); Py_VISIT(traverse_module_state->__pyx_tuple__75); Py_VISIT(traverse_module_state->__pyx_codeobj__13); Py_VISIT(traverse_module_state->__pyx_codeobj__15); Py_VISIT(traverse_module_state->__pyx_codeobj__18); Py_VISIT(traverse_module_state->__pyx_codeobj__19); Py_VISIT(traverse_module_state->__pyx_codeobj__21); Py_VISIT(traverse_module_state->__pyx_codeobj__22); Py_VISIT(traverse_module_state->__pyx_codeobj__23); Py_VISIT(traverse_module_state->__pyx_codeobj__25); Py_VISIT(traverse_module_state->__pyx_codeobj__27); Py_VISIT(traverse_module_state->__pyx_codeobj__29); Py_VISIT(traverse_module_state->__pyx_codeobj__31); Py_VISIT(traverse_module_state->__pyx_codeobj__33); Py_VISIT(traverse_module_state->__pyx_codeobj__35); Py_VISIT(traverse_module_state->__pyx_codeobj__37); Py_VISIT(traverse_module_state->__pyx_codeobj__39); Py_VISIT(traverse_module_state->__pyx_codeobj__40); Py_VISIT(traverse_module_state->__pyx_codeobj__42); Py_VISIT(traverse_module_state->__pyx_codeobj__45); Py_VISIT(traverse_module_state->__pyx_codeobj__46); Py_VISIT(traverse_module_state->__pyx_codeobj__48); Py_VISIT(traverse_module_state->__pyx_codeobj__49); Py_VISIT(traverse_module_state->__pyx_codeobj__51); Py_VISIT(traverse_module_state->__pyx_codeobj__52); Py_VISIT(traverse_module_state->__pyx_codeobj__54); Py_VISIT(traverse_module_state->__pyx_codeobj__56); Py_VISIT(traverse_module_state->__pyx_codeobj__57); Py_VISIT(traverse_module_state->__pyx_codeobj__58); Py_VISIT(traverse_module_state->__pyx_codeobj__59); Py_VISIT(traverse_module_state->__pyx_codeobj__60); Py_VISIT(traverse_module_state->__pyx_codeobj__62); Py_VISIT(traverse_module_state->__pyx_codeobj__64); Py_VISIT(traverse_module_state->__pyx_codeobj__66); Py_VISIT(traverse_module_state->__pyx_codeobj__67); Py_VISIT(traverse_module_state->__pyx_codeobj__68); Py_VISIT(traverse_module_state->__pyx_codeobj__69); Py_VISIT(traverse_module_state->__pyx_codeobj__70); Py_VISIT(traverse_module_state->__pyx_codeobj__72); Py_VISIT(traverse_module_state->__pyx_codeobj__73); Py_VISIT(traverse_module_state->__pyx_codeobj__74); Py_VISIT(traverse_module_state->__pyx_codeobj__76); return 0; } #endif /* #### Code section: module_state_defines ### */ #define __pyx_d __pyx_mstate_global->__pyx_d #define __pyx_b __pyx_mstate_global->__pyx_b #define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime #define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple #define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes #define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode #ifdef __Pyx_CyFunction_USED #define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType #endif #ifdef __Pyx_FusedFunction_USED #define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType #endif #ifdef __Pyx_Generator_USED #define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType #endif #ifdef __Pyx_IterableCoroutine_USED #define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType #endif #ifdef __Pyx_Coroutine_USED #define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType #endif #ifdef __Pyx_Coroutine_USED #define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #define __pyx_type_7_rtmidi_MidiBase __pyx_mstate_global->__pyx_type_7_rtmidi_MidiBase #define __pyx_type_7_rtmidi_MidiIn __pyx_mstate_global->__pyx_type_7_rtmidi_MidiIn #define __pyx_type_7_rtmidi_MidiOut __pyx_mstate_global->__pyx_type_7_rtmidi_MidiOut #endif #define __pyx_ptype_7_rtmidi_MidiBase __pyx_mstate_global->__pyx_ptype_7_rtmidi_MidiBase #define __pyx_ptype_7_rtmidi_MidiIn __pyx_mstate_global->__pyx_ptype_7_rtmidi_MidiIn #define __pyx_ptype_7_rtmidi_MidiOut __pyx_mstate_global->__pyx_ptype_7_rtmidi_MidiOut #define __pyx_n_s_API_LINUX_ALSA __pyx_mstate_global->__pyx_n_s_API_LINUX_ALSA #define __pyx_n_u_API_LINUX_ALSA __pyx_mstate_global->__pyx_n_u_API_LINUX_ALSA #define __pyx_n_s_API_MACOSX_CORE __pyx_mstate_global->__pyx_n_s_API_MACOSX_CORE #define __pyx_n_u_API_MACOSX_CORE __pyx_mstate_global->__pyx_n_u_API_MACOSX_CORE #define __pyx_n_s_API_RTMIDI_DUMMY __pyx_mstate_global->__pyx_n_s_API_RTMIDI_DUMMY #define __pyx_n_u_API_RTMIDI_DUMMY __pyx_mstate_global->__pyx_n_u_API_RTMIDI_DUMMY #define __pyx_n_s_API_UNIX_JACK __pyx_mstate_global->__pyx_n_s_API_UNIX_JACK #define __pyx_n_u_API_UNIX_JACK __pyx_mstate_global->__pyx_n_u_API_UNIX_JACK #define __pyx_n_s_API_UNSPECIFIED __pyx_mstate_global->__pyx_n_s_API_UNSPECIFIED #define __pyx_n_u_API_UNSPECIFIED __pyx_mstate_global->__pyx_n_u_API_UNSPECIFIED #define __pyx_n_s_API_WEB_MIDI __pyx_mstate_global->__pyx_n_s_API_WEB_MIDI #define __pyx_n_u_API_WEB_MIDI __pyx_mstate_global->__pyx_n_u_API_WEB_MIDI #define __pyx_n_s_API_WINDOWS_MM __pyx_mstate_global->__pyx_n_s_API_WINDOWS_MM #define __pyx_n_u_API_WINDOWS_MM __pyx_mstate_global->__pyx_n_u_API_WINDOWS_MM #define __pyx_kp_u_API_backend_does_not_support_cha __pyx_mstate_global->__pyx_kp_u_API_backend_does_not_support_cha #define __pyx_kp_u_API_backend_does_not_support_cha_2 __pyx_mstate_global->__pyx_kp_u_API_backend_does_not_support_cha_2 #define __pyx_kp_s_Base_general_RtMidi_exception_Al __pyx_mstate_global->__pyx_kp_s_Base_general_RtMidi_exception_Al #define __pyx_n_s_ERRORTYPE_DEBUG_WARNING __pyx_mstate_global->__pyx_n_s_ERRORTYPE_DEBUG_WARNING #define __pyx_n_u_ERRORTYPE_DEBUG_WARNING __pyx_mstate_global->__pyx_n_u_ERRORTYPE_DEBUG_WARNING #define __pyx_n_s_ERRORTYPE_DRIVER_ERROR __pyx_mstate_global->__pyx_n_s_ERRORTYPE_DRIVER_ERROR #define __pyx_n_u_ERRORTYPE_DRIVER_ERROR __pyx_mstate_global->__pyx_n_u_ERRORTYPE_DRIVER_ERROR #define __pyx_n_s_ERRORTYPE_INVALID_DEVICE __pyx_mstate_global->__pyx_n_s_ERRORTYPE_INVALID_DEVICE #define __pyx_n_u_ERRORTYPE_INVALID_DEVICE __pyx_mstate_global->__pyx_n_u_ERRORTYPE_INVALID_DEVICE #define __pyx_n_s_ERRORTYPE_INVALID_PARAMETER __pyx_mstate_global->__pyx_n_s_ERRORTYPE_INVALID_PARAMETER #define __pyx_n_u_ERRORTYPE_INVALID_PARAMETER __pyx_mstate_global->__pyx_n_u_ERRORTYPE_INVALID_PARAMETER #define __pyx_n_s_ERRORTYPE_INVALID_USE __pyx_mstate_global->__pyx_n_s_ERRORTYPE_INVALID_USE #define __pyx_n_u_ERRORTYPE_INVALID_USE __pyx_mstate_global->__pyx_n_u_ERRORTYPE_INVALID_USE #define __pyx_n_s_ERRORTYPE_MEMORY_ERROR __pyx_mstate_global->__pyx_n_s_ERRORTYPE_MEMORY_ERROR #define __pyx_n_u_ERRORTYPE_MEMORY_ERROR __pyx_mstate_global->__pyx_n_u_ERRORTYPE_MEMORY_ERROR #define __pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND __pyx_mstate_global->__pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND #define __pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND __pyx_mstate_global->__pyx_n_u_ERRORTYPE_NO_DEVICES_FOUND #define __pyx_n_s_ERRORTYPE_SYSTEM_ERROR __pyx_mstate_global->__pyx_n_s_ERRORTYPE_SYSTEM_ERROR #define __pyx_n_u_ERRORTYPE_SYSTEM_ERROR __pyx_mstate_global->__pyx_n_u_ERRORTYPE_SYSTEM_ERROR #define __pyx_n_s_ERRORTYPE_THREAD_ERROR __pyx_mstate_global->__pyx_n_s_ERRORTYPE_THREAD_ERROR #define __pyx_n_u_ERRORTYPE_THREAD_ERROR __pyx_mstate_global->__pyx_n_u_ERRORTYPE_THREAD_ERROR #define __pyx_n_s_ERRORTYPE_UNSPECIFIED __pyx_mstate_global->__pyx_n_s_ERRORTYPE_UNSPECIFIED #define __pyx_n_u_ERRORTYPE_UNSPECIFIED __pyx_mstate_global->__pyx_n_u_ERRORTYPE_UNSPECIFIED #define __pyx_n_s_ERRORTYPE_WARNING __pyx_mstate_global->__pyx_n_s_ERRORTYPE_WARNING #define __pyx_n_u_ERRORTYPE_WARNING __pyx_mstate_global->__pyx_n_u_ERRORTYPE_WARNING #define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 #define __pyx_n_s_InvalidPortError __pyx_mstate_global->__pyx_n_s_InvalidPortError #define __pyx_n_u_InvalidPortError __pyx_mstate_global->__pyx_n_u_InvalidPortError #define __pyx_n_s_InvalidUseError __pyx_mstate_global->__pyx_n_s_InvalidUseError #define __pyx_n_u_InvalidUseError __pyx_mstate_global->__pyx_n_u_InvalidUseError #define __pyx_kp_u_JACK_server_not_running __pyx_mstate_global->__pyx_kp_u_JACK_server_not_running #define __pyx_n_s_MemoryAllocationError __pyx_mstate_global->__pyx_n_s_MemoryAllocationError #define __pyx_n_u_MemoryAllocationError __pyx_mstate_global->__pyx_n_u_MemoryAllocationError #define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError #define __pyx_n_s_MidiBase __pyx_mstate_global->__pyx_n_s_MidiBase #define __pyx_n_s_MidiBase___enter __pyx_mstate_global->__pyx_n_s_MidiBase___enter #define __pyx_n_s_MidiBase___exit __pyx_mstate_global->__pyx_n_s_MidiBase___exit #define __pyx_n_s_MidiBase___reduce_cython __pyx_mstate_global->__pyx_n_s_MidiBase___reduce_cython #define __pyx_n_s_MidiBase___setstate_cython __pyx_mstate_global->__pyx_n_s_MidiBase___setstate_cython #define __pyx_n_s_MidiBase__check_port __pyx_mstate_global->__pyx_n_s_MidiBase__check_port #define __pyx_n_s_MidiBase__decode_string __pyx_mstate_global->__pyx_n_s_MidiBase__decode_string #define __pyx_n_s_MidiBase_cancel_error_callback __pyx_mstate_global->__pyx_n_s_MidiBase_cancel_error_callback #define __pyx_n_s_MidiBase_close_port __pyx_mstate_global->__pyx_n_s_MidiBase_close_port #define __pyx_n_s_MidiBase_get_port_count __pyx_mstate_global->__pyx_n_s_MidiBase_get_port_count #define __pyx_n_s_MidiBase_get_port_name __pyx_mstate_global->__pyx_n_s_MidiBase_get_port_name #define __pyx_n_s_MidiBase_get_ports __pyx_mstate_global->__pyx_n_s_MidiBase_get_ports #define __pyx_n_s_MidiBase_is_port_open __pyx_mstate_global->__pyx_n_s_MidiBase_is_port_open #define __pyx_n_s_MidiBase_open_port __pyx_mstate_global->__pyx_n_s_MidiBase_open_port #define __pyx_n_s_MidiBase_open_virtual_port __pyx_mstate_global->__pyx_n_s_MidiBase_open_virtual_port #define __pyx_n_s_MidiBase_set_client_name __pyx_mstate_global->__pyx_n_s_MidiBase_set_client_name #define __pyx_n_s_MidiBase_set_error_callback __pyx_mstate_global->__pyx_n_s_MidiBase_set_error_callback #define __pyx_n_s_MidiBase_set_port_name __pyx_mstate_global->__pyx_n_s_MidiBase_set_port_name #define __pyx_n_s_MidiIn __pyx_mstate_global->__pyx_n_s_MidiIn #define __pyx_n_u_MidiIn __pyx_mstate_global->__pyx_n_u_MidiIn #define __pyx_n_s_MidiIn___reduce_cython __pyx_mstate_global->__pyx_n_s_MidiIn___reduce_cython #define __pyx_n_s_MidiIn___setstate_cython __pyx_mstate_global->__pyx_n_s_MidiIn___setstate_cython #define __pyx_n_s_MidiIn_cancel_callback __pyx_mstate_global->__pyx_n_s_MidiIn_cancel_callback #define __pyx_n_s_MidiIn_close_port __pyx_mstate_global->__pyx_n_s_MidiIn_close_port #define __pyx_n_s_MidiIn_delete __pyx_mstate_global->__pyx_n_s_MidiIn_delete #define __pyx_n_s_MidiIn_get_current_api __pyx_mstate_global->__pyx_n_s_MidiIn_get_current_api #define __pyx_n_s_MidiIn_get_message __pyx_mstate_global->__pyx_n_s_MidiIn_get_message #define __pyx_n_s_MidiIn_ignore_types __pyx_mstate_global->__pyx_n_s_MidiIn_ignore_types #define __pyx_n_s_MidiIn_set_callback __pyx_mstate_global->__pyx_n_s_MidiIn_set_callback #define __pyx_n_s_MidiOut __pyx_mstate_global->__pyx_n_s_MidiOut #define __pyx_n_u_MidiOut __pyx_mstate_global->__pyx_n_u_MidiOut #define __pyx_n_s_MidiOut___reduce_cython __pyx_mstate_global->__pyx_n_s_MidiOut___reduce_cython #define __pyx_n_s_MidiOut___setstate_cython __pyx_mstate_global->__pyx_n_s_MidiOut___setstate_cython #define __pyx_n_s_MidiOut_delete __pyx_mstate_global->__pyx_n_s_MidiOut_delete #define __pyx_n_s_MidiOut_get_current_api __pyx_mstate_global->__pyx_n_s_MidiOut_get_current_api #define __pyx_n_s_MidiOut_send_message __pyx_mstate_global->__pyx_n_s_MidiOut_send_message #define __pyx_n_s_NoDevicesError __pyx_mstate_global->__pyx_n_s_NoDevicesError #define __pyx_n_u_NoDevicesError __pyx_mstate_global->__pyx_n_u_NoDevicesError #define __pyx_kp_u_No_port_currently_opened __pyx_mstate_global->__pyx_kp_u_No_port_currently_opened #define __pyx_kp_u_None __pyx_mstate_global->__pyx_kp_u_None #define __pyx_n_s_NotImplementedError __pyx_mstate_global->__pyx_n_s_NotImplementedError #define __pyx_n_s_OSError __pyx_mstate_global->__pyx_n_s_OSError #define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError #define __pyx_kp_s_Raised_if_a_memory_allocation_fa __pyx_mstate_global->__pyx_kp_s_Raised_if_a_memory_allocation_fa #define __pyx_kp_s_Raised_if_a_method_is_not_suppor __pyx_mstate_global->__pyx_kp_s_Raised_if_a_method_is_not_suppor #define __pyx_kp_s_Raised_if_an_error_happened_at_t __pyx_mstate_global->__pyx_kp_s_Raised_if_an_error_happened_at_t #define __pyx_kp_s_Raised_if_no_MIDI_devices_are_fo __pyx_mstate_global->__pyx_kp_s_Raised_if_no_MIDI_devices_are_fo #define __pyx_kp_s_Raised_when_an_invalid_port_numb __pyx_mstate_global->__pyx_kp_s_Raised_when_an_invalid_port_numb #define __pyx_kp_s_Raised_when_an_method_call_is_no __pyx_mstate_global->__pyx_kp_s_Raised_when_an_method_call_is_no #define __pyx_n_s_RtMidiError __pyx_mstate_global->__pyx_n_s_RtMidiError #define __pyx_n_u_RtMidiError __pyx_mstate_global->__pyx_n_u_RtMidiError #define __pyx_n_s_RtMidiError___init __pyx_mstate_global->__pyx_n_s_RtMidiError___init #define __pyx_kp_u_RtMidiIn_Client __pyx_mstate_global->__pyx_kp_u_RtMidiIn_Client #define __pyx_kp_u_RtMidiOut_Client __pyx_mstate_global->__pyx_kp_u_RtMidiOut_Client #define __pyx_kp_u_RtMidi_s __pyx_mstate_global->__pyx_kp_u_RtMidi_s #define __pyx_kp_u_RtMidi_virtual_s __pyx_mstate_global->__pyx_kp_u_RtMidi_virtual_s #define __pyx_n_s_RuntimeError __pyx_mstate_global->__pyx_n_s_RuntimeError #define __pyx_n_s_SystemError __pyx_mstate_global->__pyx_n_s_SystemError #define __pyx_n_u_SystemError __pyx_mstate_global->__pyx_n_u_SystemError #define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError #define __pyx_n_s_UnsupportedOperationError __pyx_mstate_global->__pyx_n_s_UnsupportedOperationError #define __pyx_n_u_UnsupportedOperationError __pyx_mstate_global->__pyx_n_u_UnsupportedOperationError #define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError #define __pyx_kp_u_Virtual_ports_are_not_supported __pyx_mstate_global->__pyx_kp_u_Virtual_ports_are_not_supported #define __pyx_n_s__10 __pyx_mstate_global->__pyx_n_s__10 #define __pyx_n_s__77 __pyx_mstate_global->__pyx_n_s__77 #define __pyx_kp_u__9 __pyx_mstate_global->__pyx_kp_u__9 #define __pyx_n_s_active_sense __pyx_mstate_global->__pyx_n_s_active_sense #define __pyx_n_s_all __pyx_mstate_global->__pyx_n_s_all #define __pyx_kp_u_already_opened_virtual __pyx_mstate_global->__pyx_kp_u_already_opened_virtual #define __pyx_n_s_api __pyx_mstate_global->__pyx_n_s_api #define __pyx_n_s_api_v __pyx_mstate_global->__pyx_n_s_api_v #define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines #define __pyx_n_u_auto __pyx_mstate_global->__pyx_n_u_auto #define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c #define __pyx_n_s_cancel_callback __pyx_mstate_global->__pyx_n_s_cancel_callback #define __pyx_n_s_cancel_error_callback __pyx_mstate_global->__pyx_n_s_cancel_error_callback #define __pyx_n_s_check_port __pyx_mstate_global->__pyx_n_s_check_port #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback #define __pyx_n_s_close_port __pyx_mstate_global->__pyx_n_s_close_port #define __pyx_n_u_darwin __pyx_mstate_global->__pyx_n_u_darwin #define __pyx_n_s_data __pyx_mstate_global->__pyx_n_s_data #define __pyx_n_s_decode __pyx_mstate_global->__pyx_n_s_decode #define __pyx_n_s_decode_string __pyx_mstate_global->__pyx_n_s_decode_string #define __pyx_n_s_default_error_handler __pyx_mstate_global->__pyx_n_s_default_error_handler #define __pyx_n_s_delete __pyx_mstate_global->__pyx_n_s_delete #define __pyx_n_s_delta_time __pyx_mstate_global->__pyx_n_s_delta_time #define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict #define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 #define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable #define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc #define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable #define __pyx_n_s_encoding __pyx_mstate_global->__pyx_n_s_encoding #define __pyx_n_s_endswith __pyx_mstate_global->__pyx_n_s_endswith #define __pyx_n_s_enter __pyx_mstate_global->__pyx_n_s_enter #define __pyx_kp_u_error_looking_for_port_name __pyx_mstate_global->__pyx_kp_u_error_looking_for_port_name #define __pyx_kp_u_error_sending_MIDI_message_to_po __pyx_mstate_global->__pyx_kp_u_error_sending_MIDI_message_to_po #define __pyx_kp_u_error_sending_MIDI_to_virtual_de __pyx_mstate_global->__pyx_kp_u_error_sending_MIDI_to_virtual_de #define __pyx_n_s_etype __pyx_mstate_global->__pyx_n_s_etype #define __pyx_kp_u_event_parsing_error __pyx_mstate_global->__pyx_kp_u_event_parsing_error #define __pyx_n_s_exc_info __pyx_mstate_global->__pyx_n_s_exc_info #define __pyx_n_s_exit __pyx_mstate_global->__pyx_n_s_exit #define __pyx_n_s_func __pyx_mstate_global->__pyx_n_s_func #define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc #define __pyx_n_s_get_api_display_name __pyx_mstate_global->__pyx_n_s_get_api_display_name #define __pyx_n_u_get_api_display_name __pyx_mstate_global->__pyx_n_u_get_api_display_name #define __pyx_n_s_get_api_name __pyx_mstate_global->__pyx_n_s_get_api_name #define __pyx_n_u_get_api_name __pyx_mstate_global->__pyx_n_u_get_api_name #define __pyx_n_s_get_compiled_api __pyx_mstate_global->__pyx_n_s_get_compiled_api #define __pyx_n_u_get_compiled_api __pyx_mstate_global->__pyx_n_u_get_compiled_api #define __pyx_n_s_get_compiled_api_by_name __pyx_mstate_global->__pyx_n_s_get_compiled_api_by_name #define __pyx_n_u_get_compiled_api_by_name __pyx_mstate_global->__pyx_n_u_get_compiled_api_by_name #define __pyx_n_s_get_current_api __pyx_mstate_global->__pyx_n_s_get_current_api #define __pyx_n_s_get_message __pyx_mstate_global->__pyx_n_s_get_message #define __pyx_n_s_get_port_count __pyx_mstate_global->__pyx_n_s_get_port_count #define __pyx_n_s_get_port_name __pyx_mstate_global->__pyx_n_s_get_port_name #define __pyx_n_s_get_ports __pyx_mstate_global->__pyx_n_s_get_ports #define __pyx_n_s_get_rtmidi_version __pyx_mstate_global->__pyx_n_s_get_rtmidi_version #define __pyx_n_u_get_rtmidi_version __pyx_mstate_global->__pyx_n_u_get_rtmidi_version #define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate #define __pyx_kp_s_home_runner_work_python_rtmidi __pyx_mstate_global->__pyx_kp_s_home_runner_work_python_rtmidi #define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i #define __pyx_n_u_ignore __pyx_mstate_global->__pyx_n_u_ignore #define __pyx_n_s_ignore_types __pyx_mstate_global->__pyx_n_s_ignore_types #define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import #define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init #define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass #define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing #define __pyx_n_s_inout __pyx_mstate_global->__pyx_n_s_inout #define __pyx_n_u_input __pyx_mstate_global->__pyx_n_u_input #define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine #define __pyx_kp_u_is_invalid __pyx_mstate_global->__pyx_kp_u_is_invalid #define __pyx_n_s_is_port_open __pyx_mstate_global->__pyx_n_s_is_port_open #define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled #define __pyx_n_u_latin1 __pyx_mstate_global->__pyx_n_u_latin1 #define __pyx_n_u_macroman __pyx_mstate_global->__pyx_n_u_macroman #define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main #define __pyx_n_s_message __pyx_mstate_global->__pyx_n_s_message #define __pyx_kp_u_message_longer_than_3_bytes_but __pyx_mstate_global->__pyx_kp_u_message_longer_than_3_bytes_but #define __pyx_kp_u_message_must_not_be_empty __pyx_mstate_global->__pyx_kp_u_message_must_not_be_empty #define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass #define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module #define __pyx_n_s_mro_entries __pyx_mstate_global->__pyx_n_s_mro_entries #define __pyx_n_s_msg __pyx_mstate_global->__pyx_n_s_msg #define __pyx_n_s_msg_v __pyx_mstate_global->__pyx_n_s_msg_v #define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name #define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 #define __pyx_kp_u_name_must_be_a_bytes_instance __pyx_mstate_global->__pyx_kp_u_name_must_be_a_bytes_instance #define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new #define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non #define __pyx_kp_u_no_ports_available __pyx_mstate_global->__pyx_kp_u_no_ports_available #define __pyx_n_s_open_port __pyx_mstate_global->__pyx_n_s_open_port #define __pyx_n_s_open_virtual_port __pyx_mstate_global->__pyx_n_s_open_virtual_port #define __pyx_n_u_output __pyx_mstate_global->__pyx_n_u_output #define __pyx_n_s_p __pyx_mstate_global->__pyx_n_s_p #define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle #define __pyx_n_s_platform __pyx_mstate_global->__pyx_n_s_platform #define __pyx_kp_u_port __pyx_mstate_global->__pyx_kp_u_port #define __pyx_n_u_portNumber __pyx_mstate_global->__pyx_n_u_portNumber #define __pyx_n_s_port_2 __pyx_mstate_global->__pyx_n_s_port_2 #define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare #define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError #define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum #define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result #define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state #define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type #define __pyx_n_s_pyx_unpickle_MidiBase __pyx_mstate_global->__pyx_n_s_pyx_unpickle_MidiBase #define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable #define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname #define __pyx_n_s_queue_size_limit __pyx_mstate_global->__pyx_n_s_queue_size_limit #define __pyx_kp_u_r_already_opened_s_port_i __pyx_mstate_global->__pyx_kp_u_r_already_opened_s_port_i #define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range #define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce #define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython #define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex #define __pyx_n_s_rtapi __pyx_mstate_global->__pyx_n_s_rtapi #define __pyx_n_s_rtmidi __pyx_mstate_global->__pyx_n_s_rtmidi #define __pyx_n_s_s __pyx_mstate_global->__pyx_n_s_s #define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self #define __pyx_n_s_send_message __pyx_mstate_global->__pyx_n_s_send_message #define __pyx_n_s_set_callback __pyx_mstate_global->__pyx_n_s_set_callback #define __pyx_n_s_set_client_name __pyx_mstate_global->__pyx_n_s_set_client_name #define __pyx_n_s_set_error_callback __pyx_mstate_global->__pyx_n_s_set_error_callback #define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name #define __pyx_n_s_set_port_name __pyx_mstate_global->__pyx_n_s_set_port_name #define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate #define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython #define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec #define __pyx_n_s_startswith __pyx_mstate_global->__pyx_n_s_startswith #define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state #define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource #define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super #define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys #define __pyx_n_s_sysex __pyx_mstate_global->__pyx_n_s_sysex #define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test #define __pyx_n_u_thisptr __pyx_mstate_global->__pyx_n_u_thisptr #define __pyx_n_s_timing __pyx_mstate_global->__pyx_n_s_timing #define __pyx_n_s_to_bytes __pyx_mstate_global->__pyx_n_s_to_bytes #define __pyx_n_s_type __pyx_mstate_global->__pyx_n_s_type #define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update #define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate #define __pyx_kp_u_utf_8 __pyx_mstate_global->__pyx_kp_u_utf_8 #define __pyx_n_s_warn __pyx_mstate_global->__pyx_n_s_warn #define __pyx_n_s_warnings __pyx_mstate_global->__pyx_n_s_warnings #define __pyx_n_u_win __pyx_mstate_global->__pyx_n_u_win #define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 #define __pyx_int_2218169 __pyx_mstate_global->__pyx_int_2218169 #define __pyx_int_34815411 __pyx_mstate_global->__pyx_int_34815411 #define __pyx_int_152509455 __pyx_mstate_global->__pyx_int_152509455 #define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 #define __pyx_k__4 __pyx_mstate_global->__pyx_k__4 #define __pyx_k__5 __pyx_mstate_global->__pyx_k__5 #define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ #define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 #define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 #define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 #define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 #define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 #define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 #define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 #define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 #define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 #define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 #define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 #define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24 #define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 #define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 #define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 #define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 #define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 #define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 #define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 #define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41 #define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43 #define __pyx_tuple__44 __pyx_mstate_global->__pyx_tuple__44 #define __pyx_tuple__47 __pyx_mstate_global->__pyx_tuple__47 #define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50 #define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53 #define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55 #define __pyx_tuple__61 __pyx_mstate_global->__pyx_tuple__61 #define __pyx_tuple__63 __pyx_mstate_global->__pyx_tuple__63 #define __pyx_tuple__65 __pyx_mstate_global->__pyx_tuple__65 #define __pyx_tuple__71 __pyx_mstate_global->__pyx_tuple__71 #define __pyx_tuple__75 __pyx_mstate_global->__pyx_tuple__75 #define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 #define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 #define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 #define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 #define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 #define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 #define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 #define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 #define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 #define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 #define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 #define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 #define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 #define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 #define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 #define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40 #define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42 #define __pyx_codeobj__45 __pyx_mstate_global->__pyx_codeobj__45 #define __pyx_codeobj__46 __pyx_mstate_global->__pyx_codeobj__46 #define __pyx_codeobj__48 __pyx_mstate_global->__pyx_codeobj__48 #define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 #define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51 #define __pyx_codeobj__52 __pyx_mstate_global->__pyx_codeobj__52 #define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54 #define __pyx_codeobj__56 __pyx_mstate_global->__pyx_codeobj__56 #define __pyx_codeobj__57 __pyx_mstate_global->__pyx_codeobj__57 #define __pyx_codeobj__58 __pyx_mstate_global->__pyx_codeobj__58 #define __pyx_codeobj__59 __pyx_mstate_global->__pyx_codeobj__59 #define __pyx_codeobj__60 __pyx_mstate_global->__pyx_codeobj__60 #define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62 #define __pyx_codeobj__64 __pyx_mstate_global->__pyx_codeobj__64 #define __pyx_codeobj__66 __pyx_mstate_global->__pyx_codeobj__66 #define __pyx_codeobj__67 __pyx_mstate_global->__pyx_codeobj__67 #define __pyx_codeobj__68 __pyx_mstate_global->__pyx_codeobj__68 #define __pyx_codeobj__69 __pyx_mstate_global->__pyx_codeobj__69 #define __pyx_codeobj__70 __pyx_mstate_global->__pyx_codeobj__70 #define __pyx_codeobj__72 __pyx_mstate_global->__pyx_codeobj__72 #define __pyx_codeobj__73 __pyx_mstate_global->__pyx_codeobj__73 #define __pyx_codeobj__74 __pyx_mstate_global->__pyx_codeobj__74 #define __pyx_codeobj__76 __pyx_mstate_global->__pyx_codeobj__76 /* #### Code section: module_code ### */ /* "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", 1); /* "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", 1); /* "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", 1); /* "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", 1); /* "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", 1); /* "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; char const *__pyx_t_1; std::string __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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) # <<<<<<<<<<<<<< * * */ try { __pyx_t_2 = std::string(__pyx_v_data, __pyx_v_length); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(1, 16, __pyx_L1_error) } __pyx_r = __pyx_t_2; 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:; return __pyx_r; } /* "_rtmidi.pyx":206 * # internal functions * * cdef void _cb_func(double delta_time, vector[unsigned char] *msg_v, # <<<<<<<<<<<<<< * void *cb_info) except * with gil: * """Wrapper for a Python callback function for MIDI input.""" */ static void __pyx_f_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; 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); /* "_rtmidi.pyx":209 * void *cb_info) except * 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, 209, __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, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __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, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); 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, 209, __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, 209, __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; /* "_rtmidi.pyx":210 * """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, 210, __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, 210, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyInt_From_unsigned_char(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 210, __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; /* "_rtmidi.pyx":211 * 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, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_message); __Pyx_GIVEREF(__pyx_v_message); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_message)) __PYX_ERR(0, 211, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error); __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 if (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; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_2, __pyx_v_data}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 2+__pyx_t_10); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __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; /* "_rtmidi.pyx":206 * # internal functions * * cdef void _cb_func(double delta_time, vector[unsigned char] *msg_v, # <<<<<<<<<<<<<< * void *cb_info) except * 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_AddTraceback("_rtmidi._cb_func", __pyx_clineno, __pyx_lineno, __pyx_filename); __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 } /* "_rtmidi.pyx":214 * * * 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_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); /* "_rtmidi.pyx":217 * 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, 217, __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, 217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __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, 217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); 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, 217, __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, 217, __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; /* "_rtmidi.pyx":218 * """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, 218, __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, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_decoder); __pyx_t_5 = __pyx_v_decoder; __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (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_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_2}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __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, 218, __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 if (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; } } #endif { PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_t_4, __pyx_t_3, __pyx_v_data}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 3+__pyx_t_8); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_rtmidi.pyx":214 * * * 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._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 } /* "_rtmidi.pyx":221 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a str object into bytes.""" * if isinstance(name, str): */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_1_to_bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi__to_bytes, "_to_bytes(name)\nConvert a str object into bytes."); static PyMethodDef __pyx_mdef_7_rtmidi_1_to_bytes = {"_to_bytes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_1_to_bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi__to_bytes}; static PyObject *__pyx_pw_7_rtmidi_1_to_bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_to_bytes (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 221, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_to_bytes") < 0)) __PYX_ERR(0, 221, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_to_bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 221, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi._to_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi__to_bytes(__pyx_self, __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi__to_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; 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("_to_bytes", 0); __Pyx_INCREF(__pyx_v_name); /* "_rtmidi.pyx":223 * def _to_bytes(name): * """Convert a str object into bytes.""" * if isinstance(name, str): # <<<<<<<<<<<<<< * name = bytes(name, 'utf-8') # Python 3 * */ __pyx_t_1 = PyUnicode_Check(__pyx_v_name); if (__pyx_t_1) { /* "_rtmidi.pyx":224 * """Convert a str object into bytes.""" * if isinstance(name, str): * name = bytes(name, 'utf-8') # Python 3 # <<<<<<<<<<<<<< * * if not isinstance(name, bytes): */ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_name)) __PYX_ERR(0, 224, __pyx_L1_error); __Pyx_INCREF(__pyx_kp_u_utf_8); __Pyx_GIVEREF(__pyx_kp_u_utf_8); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_kp_u_utf_8)) __PYX_ERR(0, 224, __pyx_L1_error); __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":223 * def _to_bytes(name): * """Convert a str object into bytes.""" * if isinstance(name, str): # <<<<<<<<<<<<<< * name = bytes(name, 'utf-8') # Python 3 * */ } /* "_rtmidi.pyx":226 * name = bytes(name, 'utf-8') # Python 3 * * if not isinstance(name, bytes): # <<<<<<<<<<<<<< * raise TypeError("name must be a bytes instance.") * */ __pyx_t_1 = PyBytes_Check(__pyx_v_name); __pyx_t_4 = (!__pyx_t_1); if (unlikely(__pyx_t_4)) { /* "_rtmidi.pyx":227 * * if not isinstance(name, bytes): * raise TypeError("name must be a bytes instance.") # <<<<<<<<<<<<<< * * return name */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __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, 227, __pyx_L1_error) /* "_rtmidi.pyx":226 * name = bytes(name, 'utf-8') # Python 3 * * if not isinstance(name, bytes): # <<<<<<<<<<<<<< * raise TypeError("name must be a bytes instance.") * */ } /* "_rtmidi.pyx":229 * raise TypeError("name must be a bytes instance.") * * return name # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_name); __pyx_r = __pyx_v_name; goto __pyx_L0; /* "_rtmidi.pyx":221 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a str object into bytes.""" * if isinstance(name, str): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":272 * 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_7_rtmidi_11RtMidiError_1__init__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_11RtMidiError___init__, "RtMidiError.__init__(self, msg, type=None)"); static PyMethodDef __pyx_mdef_7_rtmidi_11RtMidiError_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_11RtMidiError_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_11RtMidiError___init__}; static PyObject *__pyx_pw_7_rtmidi_11RtMidiError_1__init__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_msg = 0; PyObject *__pyx_v_type = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_msg,&__pyx_n_s_type,0}; values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 272, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_msg)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 272, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 272, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_type); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 272, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 272, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[0] = __Pyx_Arg_FASTCALL(__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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 272, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.RtMidiError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_11RtMidiError___init__(__pyx_self, __pyx_v_self, __pyx_v_msg, __pyx_v_type); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "_rtmidi.pyx":273 * * 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, 273, __pyx_L1_error) } __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 273, __pyx_L1_error); __Pyx_INCREF(__pyx_v_self); __Pyx_GIVEREF(__pyx_v_self); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self)) __PYX_ERR(0, 273, __pyx_L1_error); __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, 273, __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, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_msg}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __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; /* "_rtmidi.pyx":274 * def __init__(self, msg, type=None): * super().__init__(msg) * self.type = self.type if type is None else type # <<<<<<<<<<<<<< * * */ __pyx_t_5 = (__pyx_v_type == Py_None); if (__pyx_t_5) { __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __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, 274, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_rtmidi.pyx":272 * 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.RtMidiError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":333 * # 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_7_rtmidi_3get_api_display_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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_7_rtmidi_3get_api_display_name = {"get_api_display_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_3get_api_display_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_2get_api_display_name}; static PyObject *__pyx_pw_7_rtmidi_3get_api_display_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_api = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_api_display_name (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_api,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_api)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 333, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_api_display_name") < 0)) __PYX_ERR(0, 333, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_api = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_api_display_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 333, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.get_api_display_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_2get_api_display_name(__pyx_self, __pyx_v_api); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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", 1); /* "_rtmidi.pyx":346 * * """ * 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, 346, __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, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_rtmidi.pyx":333 * # 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.get_api_display_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":349 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_5get_api_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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_7_rtmidi_5get_api_name = {"get_api_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_5get_api_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_4get_api_name}; static PyObject *__pyx_pw_7_rtmidi_5get_api_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_api = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_api_name (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_api,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_api)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 349, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_api_name") < 0)) __PYX_ERR(0, 349, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_api = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_api_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 349, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.get_api_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_4get_api_name(__pyx_self, __pyx_v_api); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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", 1); /* "_rtmidi.pyx":362 * * """ * 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, 362, __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, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_rtmidi.pyx":349 * * * 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.get_api_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":365 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_7get_compiled_api(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ PyDoc_STRVAR(__pyx_doc_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_7_rtmidi_7get_compiled_api = {"get_compiled_api", (PyCFunction)__pyx_pw_7_rtmidi_7get_compiled_api, METH_NOARGS, __pyx_doc_7_rtmidi_6get_compiled_api}; static PyObject *__pyx_pw_7_rtmidi_7get_compiled_api(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_compiled_api (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_7_rtmidi_6get_compiled_api(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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", 1); /* "_rtmidi.pyx":377 * 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); /* "_rtmidi.pyx":378 * * 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, 378, __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, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 378, __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; /* "_rtmidi.pyx":365 * * * 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.get_compiled_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":381 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_9get_compiled_api_by_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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_7_rtmidi_9get_compiled_api_by_name = {"get_compiled_api_by_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_9get_compiled_api_by_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8get_compiled_api_by_name}; static PyObject *__pyx_pw_7_rtmidi_9get_compiled_api_by_name(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_compiled_api_by_name (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_compiled_api_by_name") < 0)) __PYX_ERR(0, 381, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_compiled_api_by_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 381, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.get_compiled_api_by_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8get_compiled_api_by_name(__pyx_self, __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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; int __pyx_t_4; std::string __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_compiled_api_by_name", 1); /* "_rtmidi.pyx":389 * * """ * 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, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 389, __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_STD_MOVE_IF_SUPPORTED(__pyx_t_5))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_rtmidi.pyx":381 * * * 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.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; } /* "_rtmidi.pyx":392 * * * 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_7_rtmidi_11get_rtmidi_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_10get_rtmidi_version, "get_rtmidi_version()\nReturn the version string of the wrapped RtMidi library."); static PyMethodDef __pyx_mdef_7_rtmidi_11get_rtmidi_version = {"get_rtmidi_version", (PyCFunction)__pyx_pw_7_rtmidi_11get_rtmidi_version, METH_NOARGS, __pyx_doc_7_rtmidi_10get_rtmidi_version}; static PyObject *__pyx_pw_7_rtmidi_11get_rtmidi_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_rtmidi_version (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_7_rtmidi_10get_rtmidi_version(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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", 1); /* "_rtmidi.pyx":394 * 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, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_rtmidi.pyx":392 * * * 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.get_rtmidi_version", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":397 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_13_default_error_handler(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_12_default_error_handler, "_default_error_handler(etype, msg, data=None)"); static PyMethodDef __pyx_mdef_7_rtmidi_13_default_error_handler = {"_default_error_handler", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_13_default_error_handler, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_12_default_error_handler}; static PyObject *__pyx_pw_7_rtmidi_13_default_error_handler(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_etype = 0; PyObject *__pyx_v_msg = 0; CYTHON_UNUSED PyObject *__pyx_v_data = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_msg,&__pyx_n_s_data,0}; values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_etype)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_msg)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("_default_error_handler", 0, 2, 3, 1); __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_default_error_handler") < 0)) __PYX_ERR(0, 397, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[0] = __Pyx_Arg_FASTCALL(__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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_default_error_handler", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 397, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi._default_error_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_12_default_error_handler(__pyx_self, __pyx_v_etype, __pyx_v_msg, __pyx_v_data); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_default_error_handler", 1); /* "_rtmidi.pyx":398 * * 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, 398, __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, 398, __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, 398, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":399 * 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, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 399, __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, 399, __pyx_L1_error) /* "_rtmidi.pyx":398 * * def _default_error_handler(etype, msg, data=None): * if etype == ERR_MEMORY_ERROR: # <<<<<<<<<<<<<< * raise MemoryAllocationError(msg) * elif etype == ERR_INVALID_PARAMETER: */ } /* "_rtmidi.pyx":400 * 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, 400, __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, 400, __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, 400, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":401 * 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, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 401, __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, 401, __pyx_L1_error) /* "_rtmidi.pyx":400 * 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): */ } /* "_rtmidi.pyx":402 * 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, 402, __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, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) { } else { __pyx_t_3 = __pyx_t_6; 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, 402, __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, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_6) { } else { __pyx_t_3 = __pyx_t_6; 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, 402, __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, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __pyx_t_6; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __pyx_t_3; if (unlikely(__pyx_t_6)) { /* "_rtmidi.pyx":403 * 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, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg)) __PYX_ERR(0, 403, __pyx_L1_error); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __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, 403, __pyx_L1_error) __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __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_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 403, __pyx_L1_error) /* "_rtmidi.pyx":402 * 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): */ } /* "_rtmidi.pyx":404 * 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_7 = __pyx_v_etype; __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::WARNING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 404, __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, 404, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_3) { } else { __pyx_t_6 = __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, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyObject_RichCompare(__pyx_t_7, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __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, 404, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __pyx_t_3; __pyx_L7_bool_binop_done:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_3 = __pyx_t_6; if (__pyx_t_3) { /* "_rtmidi.pyx":405 * 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_6 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_portNumber, __pyx_v_msg, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 405, __pyx_L1_error) if (__pyx_t_6) { } else { __pyx_t_3 = __pyx_t_6; 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, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_is_invalid}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_3 = __pyx_t_6; __pyx_L10_bool_binop_done:; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":406 * 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, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 406, __pyx_L1_error) /* "_rtmidi.pyx":405 * 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!'): */ } /* "_rtmidi.pyx":407 * 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, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_no_ports_available}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":408 * 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, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 408, __pyx_L1_error) /* "_rtmidi.pyx":407 * 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!'): */ } /* "_rtmidi.pyx":409 * 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, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_error_looking_for_port_name}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":410 * 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, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 410, __pyx_L1_error) /* "_rtmidi.pyx":409 * 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!'): */ } /* "_rtmidi.pyx":411 * 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, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_event_parsing_error}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":412 * 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_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_v_msg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 412, __pyx_L1_error) /* "_rtmidi.pyx":411 * 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.'): */ } /* "_rtmidi.pyx":413 * 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, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_error_sending_MIDI_message_to_po}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 413, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":414 * 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_7, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg)) __PYX_ERR(0, 414, __pyx_L1_error); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 414, __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, 414, __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, 414, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 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, 414, __pyx_L1_error) /* "_rtmidi.pyx":413 * 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.'): */ } /* "_rtmidi.pyx":415 * 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, 415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_kp_u_error_sending_MIDI_to_virtual_de}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 415, __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, 415, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":416 * 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, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg)) __PYX_ERR(0, 416, __pyx_L1_error); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_type, __pyx_t_7) < 0) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __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_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 416, __pyx_L1_error) /* "_rtmidi.pyx":415 * 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?'): */ } /* "_rtmidi.pyx":417 * 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, 417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_JACK_server_not_running}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 417, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { /* "_rtmidi.pyx":418 * 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_7, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg)) __PYX_ERR(0, 418, __pyx_L1_error); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 418, __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, 418, __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, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 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, 418, __pyx_L1_error) /* "_rtmidi.pyx":417 * 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: */ } /* "_rtmidi.pyx":420 * 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, 420, __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, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_msg}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __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; /* "_rtmidi.pyx":421 * 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; } /* "_rtmidi.pyx":404 * 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) */ } /* "_rtmidi.pyx":423 * return * * raise RtMidiError(msg, type=etype) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg)) __PYX_ERR(0, 423, __pyx_L1_error); __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __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, 423, __pyx_L1_error) __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __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_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(0, 423, __pyx_L1_error) /* "_rtmidi.pyx":397 * * * 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_7); __Pyx_AddTraceback("_rtmidi._default_error_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":431 * cdef object _deleted * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return NULL * */ static RtMidi *__pyx_f_7_rtmidi_8MidiBase_baseptr(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self) { RtMidi *__pyx_r; /* "_rtmidi.pyx":432 * * cdef RtMidi* baseptr(self): * return NULL # <<<<<<<<<<<<<< * * # context management */ __pyx_r = NULL; goto __pyx_L0; /* "_rtmidi.pyx":431 * cdef object _deleted * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return NULL * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "_rtmidi.pyx":435 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_1__enter__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_1__enter__ = {"__enter__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_1__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase___enter__}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_1__enter__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__enter__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__enter__", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase___enter__(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase___enter__(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__", 1); /* "_rtmidi.pyx":461 * * """ * 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; /* "_rtmidi.pyx":435 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":463 * return self * * def __exit__(self, *exc_info): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_3__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_3__exit__ = {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_3__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_2__exit__}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_3__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_exc_info = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_exc_info = __pyx_args; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_2__exit__(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_exc_info); /* function exit code */ __Pyx_DECREF(__pyx_v_exc_info); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_2__exit__(struct __pyx_obj_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_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 1); /* "_rtmidi.pyx":470 * * """ * 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, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __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; /* "_rtmidi.pyx":463 * 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.MidiBase.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":472 * 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_7_rtmidi_8MidiBase_5_check_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_8MidiBase_4_check_port, "MidiBase._check_port(self)"); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_5_check_port = {"_check_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_5_check_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_4_check_port}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_5_check_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_check_port (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("_check_port", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "_check_port", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_4_check_port(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_4_check_port(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":473 * * 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_7_rtmidi_MidiIn); if (__pyx_t_2) { __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; /* "_rtmidi.pyx":474 * 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_2 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_self->_port, __pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 474, __pyx_L1_error) if (unlikely(__pyx_t_2)) { /* "_rtmidi.pyx":475 * 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, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = 127; /* "_rtmidi.pyx":476 * 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, 476, __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, 476, __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); /* "_rtmidi.pyx":475 * 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, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (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_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __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, 475, __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, 475, __pyx_L1_error) /* "_rtmidi.pyx":474 * 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)) */ } /* "_rtmidi.pyx":477 * 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); if (unlikely(__pyx_t_2)) { /* "_rtmidi.pyx":478 * (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, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_rtmidi.pyx":479 * 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, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF((PyObject *)__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_v_self); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 479, __pyx_L1_error); __Pyx_INCREF(__pyx_v_inout); __Pyx_GIVEREF(__pyx_v_inout); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_inout)) __PYX_ERR(0, 479, __pyx_L1_error); __Pyx_INCREF(__pyx_v_self->_port); __Pyx_GIVEREF(__pyx_v_self->_port); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_self->_port)) __PYX_ERR(0, 479, __pyx_L1_error); /* "_rtmidi.pyx":478 * (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, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (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_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __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, 478, __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, 478, __pyx_L1_error) /* "_rtmidi.pyx":477 * 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)) */ } /* "_rtmidi.pyx":480 * 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; /* "_rtmidi.pyx":472 * 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.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; } /* "_rtmidi.pyx":482 * 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_7_rtmidi_8MidiBase_7_decode_string(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_8MidiBase_6_decode_string, "MidiBase._decode_string(self, s, encoding=u'auto')\nDecode given byte string with given encoding."); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_7_decode_string = {"_decode_string", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_7_decode_string, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_6_decode_string}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_7_decode_string(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_s = 0; PyObject *__pyx_v_encoding = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,&__pyx_n_s_encoding,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_auto)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_s)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 482, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_encoding); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 482, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_decode_string") < 0)) __PYX_ERR(0, 482, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_s = values[0]; __pyx_v_encoding = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_decode_string", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 482, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase._decode_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_6_decode_string(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_s, __pyx_v_encoding); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_6_decode_string(struct __pyx_obj_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_decode_string", 0); __Pyx_INCREF(__pyx_v_encoding); /* "_rtmidi.pyx":484 * 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, 484, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":485 * """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, 485, __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, 485, __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, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_u_win}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __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, 485, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { /* "_rtmidi.pyx":486 * 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); /* "_rtmidi.pyx":485 * """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; } /* "_rtmidi.pyx":487 * 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, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __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, 487, __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, 487, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 487, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { } else { __pyx_t_1 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } /* "_rtmidi.pyx":488 * 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, 488, __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, 488, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_darwin, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 488, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_6; __pyx_L5_bool_binop_done:; /* "_rtmidi.pyx":487 * 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) { /* "_rtmidi.pyx":489 * 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); /* "_rtmidi.pyx":487 * if sys.platform.startswith('win'): * encoding = 'latin1' * elif (self.get_current_api() == API_MACOSX_CORE and # <<<<<<<<<<<<<< * sys.platform == 'darwin'): * encoding = 'macroman' */ goto __pyx_L4; } /* "_rtmidi.pyx":491 * 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:; /* "_rtmidi.pyx":484 * def _decode_string(self, s, encoding='auto'): * """Decode given byte string with given encoding.""" * if encoding == 'auto': # <<<<<<<<<<<<<< * if sys.platform.startswith('win'): * encoding = 'latin1' */ } /* "_rtmidi.pyx":493 * 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, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_encoding, __pyx_n_u_ignore}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; 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_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_rtmidi.pyx":482 * 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_AddTraceback("_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; } /* "_rtmidi.pyx":495 * 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_7_rtmidi_8MidiBase_9get_port_count(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_8MidiBase_8get_port_count, "MidiBase.get_port_count(self)\nReturn the number of available MIDI input or output ports."); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_9get_port_count = {"get_port_count", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_9get_port_count, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_8get_port_count}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_9get_port_count(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_port_count (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_port_count", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_port_count", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_8get_port_count(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_8get_port_count(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations RtMidi *__pyx_t_1; unsigned int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port_count", 1); /* "_rtmidi.pyx":497 * 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_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 497, __pyx_L1_error) __pyx_t_2 = __pyx_t_1->getPortCount(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 497, __pyx_L1_error) __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_rtmidi.pyx":495 * 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_3); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":499 * 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_7_rtmidi_8MidiBase_11get_port_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 ``bytes``.\n\n "); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_11get_port_name = {"get_port_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_11get_port_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_10get_port_name}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_11get_port_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { unsigned int __pyx_v_port; PyObject *__pyx_v_encoding = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port_2,&__pyx_n_s_encoding,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_auto)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port_2)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_encoding); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_port_name") < 0)) __PYX_ERR(0, 499, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__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, 499, __pyx_L3_error) __pyx_v_encoding = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_port_name", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 499, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.get_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_10get_port_name(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_port, __pyx_v_encoding); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_10get_port_name(struct __pyx_obj_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 RtMidi *__pyx_t_1; std::string __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port_name", 1); /* "_rtmidi.pyx":513 * * """ * cdef string name = self.baseptr().getPortName(port) # <<<<<<<<<<<<<< * * if len(name): */ __pyx_t_1 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 513, __pyx_L1_error) __pyx_t_2 = __pyx_t_1->getPortName(__pyx_v_port); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 513, __pyx_L1_error) __pyx_v_name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_2); /* "_rtmidi.pyx":515 * cdef string name = self.baseptr().getPortName(port) * * if len(name): # <<<<<<<<<<<<<< * return self._decode_string(name, encoding) if encoding else name * */ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "_rtmidi.pyx":516 * * 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_5 = __Pyx_PyObject_IsTrue(__pyx_v_encoding); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 516, __pyx_L1_error) if (__pyx_t_5) { __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_decode_string); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_10 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_8, __pyx_v_encoding}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_10, 2+__pyx_t_10); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __pyx_t_3 = __pyx_t_6; __pyx_t_6 = 0; } else { __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = __pyx_t_6; __pyx_t_6 = 0; } __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_rtmidi.pyx":515 * cdef string name = self.baseptr().getPortName(port) * * if len(name): # <<<<<<<<<<<<<< * return self._decode_string(name, encoding) if encoding else name * */ } /* "_rtmidi.pyx":499 * 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_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":518 * 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_7_rtmidi_8MidiBase_13get_ports(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 ``bytes``.\n\n "); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_13get_ports = {"get_ports", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_13get_ports, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_12get_ports}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_13get_ports(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_encoding = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_encoding,0}; values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_auto)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_encoding); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_ports") < 0)) __PYX_ERR(0, 518, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_encoding = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_ports", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 518, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.get_ports", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_12get_ports(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_encoding); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_12get_ports(struct __pyx_obj_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; int __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_ports", 1); /* "_rtmidi.pyx":530 * * """ * 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, 530, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_1); /* "_rtmidi.pyx":531 * """ * 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, 531, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 531, __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, 531, __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_6 = 0; __pyx_t_7 = NULL; } else { __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 531, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 531, __pyx_L5_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 531, __pyx_L5_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 531, __pyx_L5_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 531, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 531, __pyx_L5_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 531, __pyx_L5_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 531, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_7(__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, 531, __pyx_L5_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_p, __pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":530 * * """ * 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, 530, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 530, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_8genexpr2__pyx_v_p); __Pyx_GIVEREF(__pyx_8genexpr2__pyx_v_p); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_8genexpr2__pyx_v_p)) __PYX_ERR(0, 530, __pyx_L5_error); __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 530, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_encoding, __pyx_v_encoding) < 0) __PYX_ERR(0, 530, __pyx_L5_error) __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 530, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 530, __pyx_L5_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_rtmidi.pyx":531 * """ * 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_L9_exit_scope; __pyx_L5_error:; __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_p); __pyx_8genexpr2__pyx_v_p = 0; goto __pyx_L1_error; __pyx_L9_exit_scope:; } /* exit inner scope */ __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_rtmidi.pyx":518 * 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_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":533 * 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_7_rtmidi_8MidiBase_15is_port_open(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_15is_port_open = {"is_port_open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_15is_port_open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_14is_port_open}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_15is_port_open(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_port_open (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_port_open", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_port_open", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_14is_port_open(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_14is_port_open(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":542 * * """ * 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, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_rtmidi.pyx":533 * 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.MidiBase.is_port_open", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":544 * 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_7_rtmidi_8MidiBase_17open_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 a (unicode) str or UTF-8\n encoded bytes. 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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_17open_port = {"open_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_17open_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_16open_port}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_17open_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { unsigned int __pyx_v_port; PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port_2,&__pyx_n_s_name,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port_2); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open_port") < 0)) __PYX_ERR(0, 544, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__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, 544, __pyx_L3_error) } else { __pyx_v_port = ((unsigned int)0); } __pyx_v_name = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("open_port", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 544, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.open_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_16open_port(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_port, __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_16open_port(struct __pyx_obj_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; RtMidi *__pyx_t_6; std::string __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("open_port", 0); __Pyx_INCREF(__pyx_v_name); /* "_rtmidi.pyx":576 * * """ * 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, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 576, __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; /* "_rtmidi.pyx":578 * inout = self._check_port() * * if name is None: # <<<<<<<<<<<<<< * name = "RtMidi %s" % inout * */ __pyx_t_5 = (__pyx_v_name == Py_None); if (__pyx_t_5) { /* "_rtmidi.pyx":579 * * 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, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1); __pyx_t_1 = 0; /* "_rtmidi.pyx":578 * inout = self._check_port() * * if name is None: # <<<<<<<<<<<<<< * name = "RtMidi %s" % inout * */ } /* "_rtmidi.pyx":581 * name = "RtMidi %s" % inout * * self.baseptr().openPort(port, _to_bytes(name)) # <<<<<<<<<<<<<< * self._port = port * return self */ __pyx_t_6 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __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_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6->openPort(__pyx_v_port, __pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 581, __pyx_L1_error) /* "_rtmidi.pyx":582 * * 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, 582, __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; /* "_rtmidi.pyx":583 * 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; /* "_rtmidi.pyx":544 * 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.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; } /* "_rtmidi.pyx":585 * return self * * def open_virtual_port(self, name=None): # <<<<<<<<<<<<<< * """Open a virtual MIDI input or output port. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_19open_virtual_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 a (unicode) str or UTF-8\n encoded bytes. 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 ``TypeError""``\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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_19open_virtual_port = {"open_virtual_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_19open_virtual_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_18open_virtual_port}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_19open_virtual_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 585, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open_virtual_port") < 0)) __PYX_ERR(0, 585, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("open_virtual_port", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 585, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.open_virtual_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_18open_virtual_port(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_18open_virtual_port(struct __pyx_obj_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; int __pyx_t_5; RtMidi *__pyx_t_6; PyObject *__pyx_t_7 = NULL; std::string __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("open_virtual_port", 1); /* "_rtmidi.pyx":636 * * """ * 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, 636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 636, __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, 636, __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, 636, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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, 636, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_5)) { /* "_rtmidi.pyx":637 * """ * 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, 637, __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, 637, __pyx_L1_error) /* "_rtmidi.pyx":636 * * """ * if self.get_current_api() == API_WINDOWS_MM: # <<<<<<<<<<<<<< * raise NotImplementedError("Virtual ports are not supported " * "by the Windows MultiMedia API.") */ } /* "_rtmidi.pyx":640 * "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, 640, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 640, __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; /* "_rtmidi.pyx":641 * * 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 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_rtmidi.pyx":642 * 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_5 = (__pyx_v_name == Py_None); if (__pyx_t_5) { /* "_rtmidi.pyx":641 * * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) # <<<<<<<<<<<<<< * if name is None else name)) * self._port = -1 */ __pyx_t_7 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_RtMidi_virtual_s, __pyx_v_inout); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = __pyx_t_7; __pyx_t_7 = 0; } else { /* "_rtmidi.pyx":642 * 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_7 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_1}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } /* "_rtmidi.pyx":641 * * inout = self._check_port() * self.baseptr().openVirtualPort(_to_bytes(("RtMidi virtual %s" % inout) # <<<<<<<<<<<<<< * if name is None else name)) * self._port = -1 */ __pyx_t_8 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6->openVirtualPort(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_8)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) /* "_rtmidi.pyx":643 * 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; /* "_rtmidi.pyx":644 * 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; /* "_rtmidi.pyx":585 * 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_7); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":646 * return self * * def close_port(self): # <<<<<<<<<<<<<< * """Close the MIDI input or output port opened via ``open_port``. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_21close_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_21close_port = {"close_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_21close_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_20close_port}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_21close_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close_port (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("close_port", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close_port", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_20close_port(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_20close_port(struct __pyx_obj_7_rtmidi_MidiBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; RtMidi *__pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close_port", 1); /* "_rtmidi.pyx":658 * * """ * if self._port != -1: # <<<<<<<<<<<<<< * self._port = None * self.baseptr().closePort() */ __pyx_t_1 = (__Pyx_PyInt_BoolNeObjC(__pyx_v_self->_port, __pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 658, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":659 * """ * 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; /* "_rtmidi.pyx":658 * * """ * if self._port != -1: # <<<<<<<<<<<<<< * self._port = None * self.baseptr().closePort() */ } /* "_rtmidi.pyx":660 * if self._port != -1: * self._port = None * self.baseptr().closePort() # <<<<<<<<<<<<<< * * def set_client_name(self, name): */ __pyx_t_2 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) __pyx_t_2->closePort(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) /* "_rtmidi.pyx":646 * 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_AddTraceback("_rtmidi.MidiBase.close_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":662 * self.baseptr().closePort() * * def set_client_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the MIDI client. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_23set_client_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 a (unicode)\n str or UTF-8 encoded bytes.\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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_23set_client_name = {"set_client_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_23set_client_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_22set_client_name}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_23set_client_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_client_name (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 662, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_client_name") < 0)) __PYX_ERR(0, 662, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_client_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 662, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.set_client_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_22set_client_name(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_22set_client_name(struct __pyx_obj_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; int __pyx_t_6; RtMidi *__pyx_t_7; std::string __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_client_name", 1); /* "_rtmidi.pyx":680 * * """ * 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, 680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __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, 680, __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, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; 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, 680, __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, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; 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, 680, __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, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __pyx_t_6; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __pyx_t_5; if (unlikely(__pyx_t_6)) { /* "_rtmidi.pyx":681 * """ * 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, 681, __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, 681, __pyx_L1_error) /* "_rtmidi.pyx":680 * * """ * 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.") */ } /* "_rtmidi.pyx":684 * "API backend does not support changing the client name.") * * self.baseptr().setClientName(_to_bytes(name)) # <<<<<<<<<<<<<< * * def set_port_name(self, name): */ __pyx_t_7 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_name}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_t_8 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_7->setClientName(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) /* "_rtmidi.pyx":662 * 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.MidiBase.set_client_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":686 * 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_7_rtmidi_8MidiBase_25set_port_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 a (unicode)\n str or UTF-8 encoded bytes.\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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_25set_port_name = {"set_port_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_25set_port_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_24set_port_name}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_25set_port_name(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_port_name (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_port_name") < 0)) __PYX_ERR(0, 686, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_port_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 686, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.set_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_24set_port_name(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_24set_port_name(struct __pyx_obj_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; int __pyx_t_6; RtMidi *__pyx_t_7; std::string __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_port_name", 1); /* "_rtmidi.pyx":706 * * """ * 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, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 706, __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, 706, __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, 706, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; 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, 706, __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, 706, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __pyx_t_6; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __pyx_t_5; if (unlikely(__pyx_t_6)) { /* "_rtmidi.pyx":707 * """ * 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, 707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_u_API_backend_does_not_support_cha_2}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 707, __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, 707, __pyx_L1_error) /* "_rtmidi.pyx":706 * * """ * if self.get_current_api() in (API_MACOSX_CORE, API_WINDOWS_MM): # <<<<<<<<<<<<<< * raise UnsupportedOperationError( * "API backend does not support changing the port name.") */ } /* "_rtmidi.pyx":710 * "API backend does not support changing the port name.") * * if self._port is None: # <<<<<<<<<<<<<< * raise InvalidUseError("No port currently opened.") * */ __pyx_t_6 = (__pyx_v_self->_port == Py_None); if (unlikely(__pyx_t_6)) { /* "_rtmidi.pyx":711 * * 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, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_u_No_port_currently_opened}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __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_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 711, __pyx_L1_error) /* "_rtmidi.pyx":710 * "API backend does not support changing the port name.") * * if self._port is None: # <<<<<<<<<<<<<< * raise InvalidUseError("No port currently opened.") * */ } /* "_rtmidi.pyx":713 * raise InvalidUseError("No port currently opened.") * * self.baseptr().setPortName(_to_bytes(name)) # <<<<<<<<<<<<<< * * def set_error_callback(self, func, data=None): */ __pyx_t_7 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 713, __pyx_L1_error) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 713, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 713, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_8 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 713, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_7->setPortName(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 713, __pyx_L1_error) /* "_rtmidi.pyx":686 * 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.MidiBase.set_port_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":715 * 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_7_rtmidi_8MidiBase_27set_error_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_27set_error_callback = {"set_error_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_27set_error_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_26set_error_callback}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_27set_error_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_func = 0; PyObject *__pyx_v_data = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,&__pyx_n_s_data,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 715, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 715, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_error_callback") < 0)) __PYX_ERR(0, 715, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_func = values[0]; __pyx_v_data = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_error_callback", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 715, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.set_error_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_26set_error_callback(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v_func, __pyx_v_data); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_26set_error_callback(struct __pyx_obj_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; RtMidi *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_error_callback", 1); /* "_rtmidi.pyx":738 * * """ * 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, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_func)) __PYX_ERR(0, 738, __pyx_L1_error); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_data)) __PYX_ERR(0, 738, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1)) __PYX_ERR(0, 738, __pyx_L1_error); __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; /* "_rtmidi.pyx":739 * """ * self._error_callback = (func, data, self._decode_string) * self.baseptr().setErrorCallback(&_cb_error_func, # <<<<<<<<<<<<<< * self._error_callback) * */ __pyx_t_3 = ((struct __pyx_vtabstruct_7_rtmidi_MidiBase *)__pyx_v_self->__pyx_vtab)->baseptr(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 739, __pyx_L1_error) /* "_rtmidi.pyx":740 * self._error_callback = (func, data, self._decode_string) * self.baseptr().setErrorCallback(&_cb_error_func, * self._error_callback) # <<<<<<<<<<<<<< * * def cancel_error_callback(self): */ __pyx_t_3->setErrorCallback((&__pyx_f_7_rtmidi__cb_error_func), ((void *)__pyx_v_self->_error_callback)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 739, __pyx_L1_error) /* "_rtmidi.pyx":715 * 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.MidiBase.set_error_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":742 * self._error_callback) * * def cancel_error_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for errors. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_29cancel_error_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_29cancel_error_callback = {"cancel_error_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_29cancel_error_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_28cancel_error_callback}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_29cancel_error_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("cancel_error_callback (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("cancel_error_callback", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancel_error_callback", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_28cancel_error_callback(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_28cancel_error_callback(struct __pyx_obj_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_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("cancel_error_callback", 1); /* "_rtmidi.pyx":749 * * """ * 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, 749, __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, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __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, 749, __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; /* "_rtmidi.pyx":742 * 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.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_7_rtmidi_8MidiBase_31__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_8MidiBase_30__reduce_cython__, "MidiBase.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_31__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_30__reduce_cython__}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_31__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_30__reduce_cython__(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_30__reduce_cython__(struct __pyx_obj_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; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->_deleted)) __PYX_ERR(1, 5, __pyx_L1_error); __Pyx_INCREF(__pyx_v_self->_error_callback); __Pyx_GIVEREF(__pyx_v_self->_error_callback); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->_error_callback)) __PYX_ERR(1, 5, __pyx_L1_error); __Pyx_INCREF(__pyx_v_self->_port); __Pyx_GIVEREF(__pyx_v_self->_port); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->_port)) __PYX_ERR(1, 5, __pyx_L1_error); __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); if (__pyx_t_2) { /* "(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); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 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), 0x2133db3, None), state */ /*else*/ { __pyx_t_4 = (__pyx_v_self->_deleted != Py_None); if (!__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = (__pyx_v_self->_error_callback != Py_None); if (!__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = (__pyx_v_self->_port != Py_None); __pyx_t_2 = __pyx_t_4; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_2; } __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), 0x2133db3, None), state * else: */ if (__pyx_v_use_setstate) { /* "(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), 0x2133db3, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_MidiBase); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_int_34815411); __Pyx_GIVEREF(__pyx_int_34815411); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_34815411)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 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), 0x2133db3, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, None), state * else: * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_MidiBase); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_int_34815411); __Pyx_GIVEREF(__pyx_int_34815411); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_34815411)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_5 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 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_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_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), 0x2133db3, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_8MidiBase_33__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_8MidiBase_32__setstate_cython__, "MidiBase.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_7_rtmidi_8MidiBase_33__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_32__setstate_cython__}; static PyObject *__pyx_pw_7_rtmidi_8MidiBase_33__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiBase.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_8MidiBase_32__setstate_cython__(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_8MidiBase_32__setstate_cython__(struct __pyx_obj_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__", 1); /* "(tree fragment)":17 * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, 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) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_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), 0x2133db3, 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.MidiBase.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":796 * cdef object _callback * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ static RtMidi *__pyx_f_7_rtmidi_6MidiIn_baseptr(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self) { RtMidi *__pyx_r; /* "_rtmidi.pyx":797 * * cdef RtMidi* baseptr(self): * return self.thisptr # <<<<<<<<<<<<<< * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None, */ __pyx_r = __pyx_v_self->thisptr; goto __pyx_L0; /* "_rtmidi.pyx":796 * cdef object _callback * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "_rtmidi.pyx":799 * 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_7_rtmidi_6MidiIn_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_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; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rtapi,&__pyx_n_s_name,&__pyx_n_s_queue_size_limit,0}; values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rtapi); if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_queue_size_limit); if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 799, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__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, 799, __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, 800, __pyx_L3_error) } else { __pyx_v_queue_size_limit = ((unsigned int)0x400); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 3, __pyx_nargs); __PYX_ERR(0, 799, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiIn.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn___cinit__(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_rtapi, __pyx_v_name, __pyx_v_queue_size_limit); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7_rtmidi_6MidiIn___cinit__(struct __pyx_obj_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; PyObject *__pyx_t_2 = NULL; 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; int __pyx_t_8; std::string __pyx_t_9; RtMidiIn *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; char const *__pyx_t_16; PyObject *__pyx_t_17 = NULL; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_name); /* "_rtmidi.pyx":806 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiIn Client" * */ __pyx_t_1 = (__pyx_v_name == Py_None); if (__pyx_t_1) { /* "_rtmidi.pyx":807 * """ * 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); /* "_rtmidi.pyx":806 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiIn Client" * */ } /* "_rtmidi.pyx":809 * 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_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "_rtmidi.pyx":810 * * 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_6, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 810, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_name}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 810, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 810, __pyx_L4_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; try { __pyx_t_10 = new RtMidiIn(__pyx_v_rtapi, __pyx_t_9, __pyx_v_queue_size_limit); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 810, __pyx_L4_error) } __pyx_v_self->thisptr = __pyx_t_10; /* "_rtmidi.pyx":809 * name = "RtMidiIn Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: */ } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "_rtmidi.pyx":811 * 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_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_8) { __Pyx_AddTraceback("_rtmidi.MidiIn.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 811, __pyx_L6_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_exc = __pyx_t_6; /*try:*/ { /* "_rtmidi.pyx":812 * 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_11, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_12 = __Pyx_PyObject_Str(__pyx_v_exc); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyTuple_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_12); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12)) __PYX_ERR(0, 812, __pyx_L15_error); __pyx_t_12 = 0; __pyx_t_12 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_14 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); if (PyDict_SetItem(__pyx_t_12, __pyx_n_s_type, __pyx_t_14) < 0) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 812, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_Raise(__pyx_t_14, 0, 0, 0); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __PYX_ERR(0, 812, __pyx_L15_error) } /* "_rtmidi.pyx":811 * 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_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 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; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); __Pyx_XGOTREF(__pyx_t_17); __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_t_8 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename; { __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19); __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16; goto __pyx_L6_except_error; } } } goto __pyx_L6_except_error; /* "_rtmidi.pyx":809 * name = "RtMidiIn Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiIn(rtapi, _to_bytes(name), queue_size_limit) * except RuntimeError as exc: */ __pyx_L6_except_error:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L9_try_end:; } /* "_rtmidi.pyx":814 * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * * self.set_error_callback(_default_error_handler) # <<<<<<<<<<<<<< * self._callback = None * self._port = None */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_error_callback); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_default_error_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_14 = NULL; __pyx_t_15 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_5}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_15, 1+__pyx_t_15); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "_rtmidi.pyx":815 * * 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; /* "_rtmidi.pyx":816 * 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; /* "_rtmidi.pyx":817 * 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; /* "_rtmidi.pyx":799 * 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_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":819 * 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_7_rtmidi_6MidiIn_3get_current_api(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_3get_current_api = {"get_current_api", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_3get_current_api, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_2get_current_api}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_3get_current_api(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_current_api (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_current_api", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_current_api", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_2get_current_api(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_2get_current_api(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":831 * * """ * 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, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_rtmidi.pyx":819 * 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.MidiIn.get_current_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":833 * return self.thisptr.getCurrentApi() * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* Python wrapper */ static void __pyx_pw_7_rtmidi_6MidiIn_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_7_rtmidi_6MidiIn_5__dealloc__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_7_rtmidi_6MidiIn_4__dealloc__(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_7_rtmidi_6MidiIn_4__dealloc__(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self) { int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "_rtmidi.pyx":835 * 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, 835, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":836 * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): * del self.thisptr # <<<<<<<<<<<<<< * * def delete(self): */ delete __pyx_v_self->thisptr; /* "_rtmidi.pyx":835 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ } /* "_rtmidi.pyx":833 * 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.MidiIn.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; } /* "_rtmidi.pyx":838 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_7delete(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_7delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_7delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_6delete}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_7delete(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("delete", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "delete", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_6delete(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_6delete(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":855 * * """ * 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, 855, __pyx_L1_error) __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { /* "_rtmidi.pyx":856 * """ * if not self._deleted: * del self.thisptr # <<<<<<<<<<<<<< * self._deleted = True * */ delete __pyx_v_self->thisptr; /* "_rtmidi.pyx":857 * 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; /* "_rtmidi.pyx":855 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ } /* "_rtmidi.pyx":838 * 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.MidiIn.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":859 * self._deleted = True * * @property # <<<<<<<<<<<<<< * def is_deleted(self): * return self._deleted */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_10is_deleted_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_10is_deleted_1__get__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_10is_deleted___get__(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_10is_deleted___get__(struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 1); /* "_rtmidi.pyx":861 * @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; /* "_rtmidi.pyx":859 * self._deleted = True * * @property # <<<<<<<<<<<<<< * def is_deleted(self): * return self._deleted */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":863 * return self._deleted * * def cancel_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for MIDI input. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_9cancel_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_9cancel_callback = {"cancel_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_9cancel_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_8cancel_callback}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_9cancel_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("cancel_callback (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("cancel_callback", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancel_callback", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_8cancel_callback(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_8cancel_callback(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":870 * * """ * 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, 870, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":871 * """ * if self._callback: * self.thisptr.cancelCallback() # <<<<<<<<<<<<<< * self._callback = None * */ __pyx_v_self->thisptr->cancelCallback(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 871, __pyx_L1_error) /* "_rtmidi.pyx":872 * 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; /* "_rtmidi.pyx":870 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.thisptr.cancelCallback() * self._callback = None */ } /* "_rtmidi.pyx":863 * 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.MidiIn.cancel_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":874 * self._callback = None * * def close_port(self): # <<<<<<<<<<<<<< * self.cancel_callback() * MidiBase.close_port(self) */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_11close_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_6MidiIn_10close_port, "MidiIn.close_port(self)"); static PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_11close_port = {"close_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_11close_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_10close_port}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_11close_port(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close_port (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("close_port", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close_port", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_10close_port(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_10close_port(struct __pyx_obj_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_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close_port", 1); /* "_rtmidi.pyx":875 * * 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, 875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 875, __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; /* "_rtmidi.pyx":876 * 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_7_rtmidi_MidiBase), __pyx_n_s_close_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (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_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 876, __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; /* "_rtmidi.pyx":874 * 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.MidiIn.close_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":880 * close_port.__doc__ == MidiBase.close_port.__doc__ * * def get_message(self): # <<<<<<<<<<<<<< * """Poll for MIDI input. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_6MidiIn_13get_message(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_13get_message = {"get_message", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_13get_message, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_12get_message}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_13get_message(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_message (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_message", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_message", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_12get_message(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_12get_message(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":894 * """ * 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, 894, __pyx_L1_error) __pyx_v_delta_time = __pyx_t_1; /* "_rtmidi.pyx":896 * 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()); if (__pyx_t_2) { /* "_rtmidi.pyx":897 * * 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, 897, __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, 897, __pyx_L1_error) } __pyx_t_8 = __Pyx_PyInt_From_unsigned_char(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 897, __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; /* "_rtmidi.pyx":898 * 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, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_message); __Pyx_GIVEREF(__pyx_v_message); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_message)) __PYX_ERR(0, 898, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3)) __PYX_ERR(0, 898, __pyx_L1_error); __pyx_t_3 = 0; __pyx_r = __pyx_t_8; __pyx_t_8 = 0; goto __pyx_L0; /* "_rtmidi.pyx":896 * 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) */ } /* "_rtmidi.pyx":880 * 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.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; } /* "_rtmidi.pyx":900 * 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_7_rtmidi_6MidiIn_15ignore_types(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_15ignore_types = {"ignore_types", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_15ignore_types, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_14ignore_types}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_15ignore_types(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_sysex = 0; PyObject *__pyx_v_timing = 0; PyObject *__pyx_v_active_sense = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sysex,&__pyx_n_s_timing,&__pyx_n_s_active_sense,0}; values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sysex); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 900, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timing); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 900, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_active_sense); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 900, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ignore_types") < 0)) __PYX_ERR(0, 900, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("ignore_types", 0, 0, 3, __pyx_nargs); __PYX_ERR(0, 900, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiIn.ignore_types", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_14ignore_types(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_sysex, __pyx_v_timing, __pyx_v_active_sense); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_14ignore_types(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":936 * * """ * 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, 936, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_timing); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 936, __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, 936, __pyx_L1_error) __pyx_v_self->thisptr->ignoreTypes(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 936, __pyx_L1_error) /* "_rtmidi.pyx":900 * 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.MidiIn.ignore_types", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":938 * 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_7_rtmidi_6MidiIn_17set_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_17set_callback = {"set_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_17set_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_16set_callback}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_17set_callback(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_func = 0; PyObject *__pyx_v_data = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,&__pyx_n_s_data,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 938, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 938, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_callback") < 0)) __PYX_ERR(0, 938, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_func = values[0]; __pyx_v_data = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("set_callback", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 938, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiIn.set_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_16set_callback(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v_func, __pyx_v_data); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_16set_callback(struct __pyx_obj_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_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_callback", 1); /* "_rtmidi.pyx":957 * * """ * 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, 957, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":958 * """ * 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, 958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 958, __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; /* "_rtmidi.pyx":957 * * """ * if self._callback: # <<<<<<<<<<<<<< * self.cancel_callback() * */ } /* "_rtmidi.pyx":960 * 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, 960, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_func)) __PYX_ERR(0, 960, __pyx_L1_error); __Pyx_INCREF(__pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_data)) __PYX_ERR(0, 960, __pyx_L1_error); __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; /* "_rtmidi.pyx":961 * * self._callback = (func, data) * self.thisptr.setCallback(&_cb_func, self._callback) # <<<<<<<<<<<<<< * * */ __pyx_v_self->thisptr->setCallback((&__pyx_f_7_rtmidi__cb_func), ((void *)__pyx_v_self->_callback)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 961, __pyx_L1_error) /* "_rtmidi.pyx":938 * 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.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_7_rtmidi_6MidiIn_19__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_6MidiIn_18__reduce_cython__, "MidiIn.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_19__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_18__reduce_cython__}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_19__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_18__reduce_cython__(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_AddTraceback("_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_7_rtmidi_6MidiIn_21__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_6MidiIn_20__setstate_cython__, "MidiIn.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_7_rtmidi_6MidiIn_21__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_20__setstate_cython__}; static PyObject *__pyx_pw_7_rtmidi_6MidiIn_21__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiIn.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_6MidiIn_20__setstate_cython__(((struct __pyx_obj_7_rtmidi_MidiIn *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_6MidiIn_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiIn *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_AddTraceback("_rtmidi.MidiIn.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":1001 * cdef RtMidiOut *thisptr * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ static RtMidi *__pyx_f_7_rtmidi_7MidiOut_baseptr(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self) { RtMidi *__pyx_r; /* "_rtmidi.pyx":1002 * * cdef RtMidi* baseptr(self): * return self.thisptr # <<<<<<<<<<<<<< * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): */ __pyx_r = __pyx_v_self->thisptr; goto __pyx_L0; /* "_rtmidi.pyx":1001 * cdef RtMidiOut *thisptr * * cdef RtMidi* baseptr(self): # <<<<<<<<<<<<<< * return self.thisptr * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "_rtmidi.pyx":1004 * 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_7_rtmidi_7MidiOut_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_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; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rtapi,&__pyx_n_s_name,0}; values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rtapi); if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1004, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1004, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 1004, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__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, 1004, __pyx_L3_error) } else { __pyx_v_rtapi = __pyx_k__5; } __pyx_v_name = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 1004, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiOut.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut___cinit__(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self), __pyx_v_rtapi, __pyx_v_name); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7_rtmidi_7MidiOut___cinit__(struct __pyx_obj_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; PyObject *__pyx_t_2 = NULL; 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; int __pyx_t_8; std::string __pyx_t_9; RtMidiOut *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; char const *__pyx_t_16; PyObject *__pyx_t_17 = NULL; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_name); /* "_rtmidi.pyx":1010 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiOut Client" * */ __pyx_t_1 = (__pyx_v_name == Py_None); if (__pyx_t_1) { /* "_rtmidi.pyx":1011 * """ * 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); /* "_rtmidi.pyx":1010 * * """ * if name is None: # <<<<<<<<<<<<<< * name = "RtMidiOut Client" * */ } /* "_rtmidi.pyx":1013 * 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_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "_rtmidi.pyx":1014 * * 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_6, __pyx_n_s_to_bytes); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1014, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_name}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1014, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1014, __pyx_L4_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; try { __pyx_t_10 = new RtMidiOut(__pyx_v_rtapi, __pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1014, __pyx_L4_error) } __pyx_v_self->thisptr = __pyx_t_10; /* "_rtmidi.pyx":1013 * name = "RtMidiOut Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: */ } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "_rtmidi.pyx":1015 * try: * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: # <<<<<<<<<<<<<< * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_8) { __Pyx_AddTraceback("_rtmidi.MidiOut.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 1015, __pyx_L6_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_exc = __pyx_t_6; /*try:*/ { /* "_rtmidi.pyx":1016 * 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_11, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_12 = __Pyx_PyObject_Str(__pyx_v_exc); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyTuple_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_12); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12)) __PYX_ERR(0, 1016, __pyx_L15_error); __pyx_t_12 = 0; __pyx_t_12 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_14 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); if (PyDict_SetItem(__pyx_t_12, __pyx_n_s_type, __pyx_t_14) < 0) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1016, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_Raise(__pyx_t_14, 0, 0, 0); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __PYX_ERR(0, 1016, __pyx_L15_error) } /* "_rtmidi.pyx":1015 * 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_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 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; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); __Pyx_XGOTREF(__pyx_t_17); __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_t_8 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename; { __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19); __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16; goto __pyx_L6_except_error; } } } goto __pyx_L6_except_error; /* "_rtmidi.pyx":1013 * name = "RtMidiOut Client" * * try: # <<<<<<<<<<<<<< * self.thisptr = new RtMidiOut(rtapi, _to_bytes(name)) * except RuntimeError as exc: */ __pyx_L6_except_error:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L9_try_end:; } /* "_rtmidi.pyx":1018 * raise SystemError(str(exc), type=ERR_DRIVER_ERROR) * * self.set_error_callback(_default_error_handler) # <<<<<<<<<<<<<< * self._port = None * self._deleted = False */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_error_callback); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_default_error_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_14 = NULL; __pyx_t_15 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_5}; __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_15, 1+__pyx_t_15); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "_rtmidi.pyx":1019 * * 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; /* "_rtmidi.pyx":1020 * 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; /* "_rtmidi.pyx":1004 * 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_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("_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; } /* "_rtmidi.pyx":1022 * self._deleted = False * * def __dealloc__(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): */ /* Python wrapper */ static void __pyx_pw_7_rtmidi_7MidiOut_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_7_rtmidi_7MidiOut_3__dealloc__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_7_rtmidi_7MidiOut_2__dealloc__(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_7_rtmidi_7MidiOut_2__dealloc__(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self) { int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "_rtmidi.pyx":1024 * 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, 1024, __pyx_L1_error) if (__pyx_t_1) { /* "_rtmidi.pyx":1025 * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): * del self.thisptr # <<<<<<<<<<<<<< * * def delete(self): */ delete __pyx_v_self->thisptr; /* "_rtmidi.pyx":1024 * def __dealloc__(self): * """De-allocate pointer to C++ class instance.""" * if hasattr(self, "thisptr"): # <<<<<<<<<<<<<< * del self.thisptr * */ } /* "_rtmidi.pyx":1022 * 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.MidiOut.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; } /* "_rtmidi.pyx":1027 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_7MidiOut_5delete(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_7MidiOut_5delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_4delete}; static PyObject *__pyx_pw_7_rtmidi_7MidiOut_5delete(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("delete", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "delete", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_4delete(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_4delete(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":1044 * * """ * 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, 1044, __pyx_L1_error) __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { /* "_rtmidi.pyx":1045 * """ * if not self._deleted: * del self.thisptr # <<<<<<<<<<<<<< * self._deleted = True * */ delete __pyx_v_self->thisptr; /* "_rtmidi.pyx":1046 * 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; /* "_rtmidi.pyx":1044 * * """ * if not self._deleted: # <<<<<<<<<<<<<< * del self.thisptr * self._deleted = True */ } /* "_rtmidi.pyx":1027 * 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.MidiOut.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":1048 * self._deleted = True * * @property # <<<<<<<<<<<<<< * def is_deleted(self): * return self._deleted */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_7MidiOut_10is_deleted_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7_rtmidi_7MidiOut_10is_deleted_1__get__(PyObject *__pyx_v_self) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_10is_deleted___get__(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_10is_deleted___get__(struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 1); /* "_rtmidi.pyx":1050 * @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; /* "_rtmidi.pyx":1048 * self._deleted = True * * @property # <<<<<<<<<<<<<< * def is_deleted(self): * return self._deleted */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":1052 * 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_7_rtmidi_7MidiOut_7get_current_api(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 PyMethodDef __pyx_mdef_7_rtmidi_7MidiOut_7get_current_api = {"get_current_api", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_7get_current_api, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_6get_current_api}; static PyObject *__pyx_pw_7_rtmidi_7MidiOut_7get_current_api(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_current_api (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_current_api", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_current_api", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_6get_current_api(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_6get_current_api(struct __pyx_obj_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", 1); /* "_rtmidi.pyx":1064 * * """ * 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, 1064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_rtmidi.pyx":1052 * 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.MidiOut.get_current_api", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_rtmidi.pyx":1066 * return self.thisptr.getCurrentApi() * * def send_message(self, message): # <<<<<<<<<<<<<< * """Send a MIDI message to the output port. * */ /* Python wrapper */ static PyObject *__pyx_pw_7_rtmidi_7MidiOut_9send_message(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_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 .. note:: with some backend APIs (notably ```WINDOWS_MM``) this function\n blocks until the whole message is sent.\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 PyMethodDef __pyx_mdef_7_rtmidi_7MidiOut_9send_message = {"send_message", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_9send_message, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_8send_message}; static PyObject *__pyx_pw_7_rtmidi_7MidiOut_9send_message(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_message = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("send_message (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_message,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_message)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1066, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "send_message") < 0)) __PYX_ERR(0, 1066, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v_message = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("send_message", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1066, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiOut.send_message", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_8send_message(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self), __pyx_v_message); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_8send_message(struct __pyx_obj_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 PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; unsigned char __pyx_t_9; int __pyx_t_10; int __pyx_t_11; __Pyx_FakeReference __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("send_message", 1); /* "_rtmidi.pyx":1092 * cdef vector[unsigned char] msg_v * * try: # <<<<<<<<<<<<<< * msg_v.reserve(len(message)) * except TypeError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "_rtmidi.pyx":1093 * * try: * msg_v.reserve(len(message)) # <<<<<<<<<<<<<< * except TypeError: * pass */ __pyx_t_4 = PyObject_Length(__pyx_v_message); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1093, __pyx_L3_error) try { __pyx_v_msg_v.reserve(__pyx_t_4); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1093, __pyx_L3_error) } /* "_rtmidi.pyx":1092 * cdef vector[unsigned char] msg_v * * try: # <<<<<<<<<<<<<< * msg_v.reserve(len(message)) * except TypeError: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "_rtmidi.pyx":1094 * try: * msg_v.reserve(len(message)) * except TypeError: # <<<<<<<<<<<<<< * pass * */ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_5) { __Pyx_ErrRestore(0,0,0); goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; /* "_rtmidi.pyx":1092 * cdef vector[unsigned char] msg_v * * try: # <<<<<<<<<<<<<< * msg_v.reserve(len(message)) * except TypeError: */ __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L8_try_end:; } /* "_rtmidi.pyx":1097 * pass * * for c in message: # <<<<<<<<<<<<<< * msg_v.push_back(c) * */ if (likely(PyList_CheckExact(__pyx_v_message)) || PyTuple_CheckExact(__pyx_v_message)) { __pyx_t_6 = __pyx_v_message; __Pyx_INCREF(__pyx_t_6); __pyx_t_4 = 0; __pyx_t_7 = NULL; } else { __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_message); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1097, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_6))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1097, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_8 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 1097, __pyx_L1_error) #else __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1097, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 1097, __pyx_L1_error) #else __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif } } else { __pyx_t_8 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1097, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_8); } __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_8); __pyx_t_8 = 0; /* "_rtmidi.pyx":1098 * * for c in message: * msg_v.push_back(c) # <<<<<<<<<<<<<< * * if msg_v.size() == 0: */ __pyx_t_9 = __Pyx_PyInt_As_unsigned_char(__pyx_v_c); if (unlikely((__pyx_t_9 == (unsigned char)-1) && PyErr_Occurred())) __PYX_ERR(0, 1098, __pyx_L1_error) try { __pyx_v_msg_v.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1098, __pyx_L1_error) } /* "_rtmidi.pyx":1097 * pass * * for c in message: # <<<<<<<<<<<<<< * msg_v.push_back(c) * */ } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_rtmidi.pyx":1100 * msg_v.push_back(c) * * if msg_v.size() == 0: # <<<<<<<<<<<<<< * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: */ __pyx_t_10 = (__pyx_v_msg_v.size() == 0); if (unlikely(__pyx_t_10)) { /* "_rtmidi.pyx":1101 * * if msg_v.size() == 0: * raise ValueError("'message' must not be empty.") # <<<<<<<<<<<<<< * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " */ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1101, __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, 1101, __pyx_L1_error) /* "_rtmidi.pyx":1100 * msg_v.push_back(c) * * if msg_v.size() == 0: # <<<<<<<<<<<<<< * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: */ } /* "_rtmidi.pyx":1102 * if msg_v.size() == 0: * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: # <<<<<<<<<<<<<< * raise ValueError("'message' longer than 3 bytes but does not " * "start with 0xF0.") */ __pyx_t_11 = (__pyx_v_msg_v.size() > 3); if (__pyx_t_11) { } else { __pyx_t_10 = __pyx_t_11; goto __pyx_L13_bool_binop_done; } try { __pyx_t_12 = __pyx_v_msg_v.at(0); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 1102, __pyx_L1_error) } __pyx_t_11 = (__pyx_t_12 != 0xF0); __pyx_t_10 = __pyx_t_11; __pyx_L13_bool_binop_done:; if (unlikely(__pyx_t_10)) { /* "_rtmidi.pyx":1103 * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " # <<<<<<<<<<<<<< * "start with 0xF0.") * */ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1103, __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, 1103, __pyx_L1_error) /* "_rtmidi.pyx":1102 * if msg_v.size() == 0: * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: # <<<<<<<<<<<<<< * raise ValueError("'message' longer than 3 bytes but does not " * "start with 0xF0.") */ } /* "_rtmidi.pyx":1106 * "start with 0xF0.") * * self.thisptr.sendMessage(&msg_v) # <<<<<<<<<<<<<< */ __pyx_v_self->thisptr->sendMessage((&__pyx_v_msg_v)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1106, __pyx_L1_error) /* "_rtmidi.pyx":1066 * 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_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_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_7_rtmidi_7MidiOut_11__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_7MidiOut_10__reduce_cython__, "MidiOut.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_7_rtmidi_7MidiOut_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_10__reduce_cython__}; static PyObject *__pyx_pw_7_rtmidi_7MidiOut_11__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_10__reduce_cython__(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_AddTraceback("_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_7_rtmidi_7MidiOut_13__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_7MidiOut_12__setstate_cython__, "MidiOut.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_7_rtmidi_7MidiOut_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_12__setstate_cython__}; static PyObject *__pyx_pw_7_rtmidi_7MidiOut_13__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.MidiOut.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_7MidiOut_12__setstate_cython__(((struct __pyx_obj_7_rtmidi_MidiOut *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7_rtmidi_7MidiOut_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7_rtmidi_MidiOut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_AddTraceback("_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_7_rtmidi_15__pyx_unpickle_MidiBase(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_7_rtmidi_14__pyx_unpickle_MidiBase, "__pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state)"); static PyMethodDef __pyx_mdef_7_rtmidi_15__pyx_unpickle_MidiBase = {"__pyx_unpickle_MidiBase", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_15__pyx_unpickle_MidiBase, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_14__pyx_unpickle_MidiBase}; static PyObject *__pyx_pw_7_rtmidi_15__pyx_unpickle_MidiBase(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_MidiBase", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_MidiBase") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[2] = __Pyx_Arg_FASTCALL(__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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_MidiBase", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("_rtmidi.__pyx_unpickle_MidiBase", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7_rtmidi_14__pyx_unpickle_MidiBase(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_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 PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_MidiBase", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x2133db3, 0x021d8b9, 0x9171c0f): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 0x9171c0f) = (_deleted, _error_callback, _port))" % __pyx_checksum */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__8, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0x2133db3, 0x021d8b9, 0x9171c0f): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 0x9171c0f) = (_deleted, _error_callback, _port))" % __pyx_checksum * __pyx_result = MidiBase.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0x2133db3, 0x021d8b9, 0x9171c0f): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 0x9171c0f) = (_deleted, _error_callback, _port))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = MidiBase.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x2133db3, 0x021d8b9, 0x9171c0f): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 0x9171c0f) = (_deleted, _error_callback, _port))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 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_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7_rtmidi_MidiBase), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v___pyx_result = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 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_2 = (__pyx_v___pyx_state != Py_None); if (__pyx_t_2) { /* "(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) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_1 = __pyx_f_7_rtmidi___pyx_unpickle_MidiBase__set_state(((struct __pyx_obj_7_rtmidi_MidiBase *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 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_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("_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_7_rtmidi___pyx_unpickle_MidiBase__set_state(struct __pyx_obj_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; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_MidiBase__set_state", 1); /* "(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 = __Pyx_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); 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_2 = __pyx_t_4; __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_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_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; } static struct __pyx_vtabstruct_7_rtmidi_MidiBase __pyx_vtable_7_rtmidi_MidiBase; static PyObject *__pyx_tp_new_7_rtmidi_MidiBase(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_7_rtmidi_MidiBase *p; PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif p = ((struct __pyx_obj_7_rtmidi_MidiBase *)o); p->__pyx_vtab = __pyx_vtabptr_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_7_rtmidi_MidiBase(PyObject *o) { struct __pyx_obj_7_rtmidi_MidiBase *p = (struct __pyx_obj_7_rtmidi_MidiBase *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7_rtmidi_MidiBase) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->_port); Py_CLEAR(p->_error_callback); Py_CLEAR(p->_deleted); #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); if (tp_free) tp_free(o); } #endif } static int __pyx_tp_traverse_7_rtmidi_MidiBase(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7_rtmidi_MidiBase *p = (struct __pyx_obj_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_7_rtmidi_MidiBase(PyObject *o) { PyObject* tmp; struct __pyx_obj_7_rtmidi_MidiBase *p = (struct __pyx_obj_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_7_rtmidi_MidiBase[] = { {"__enter__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_1__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase___enter__}, {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_3__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_2__exit__}, {"_check_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_5_check_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_4_check_port}, {"_decode_string", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_7_decode_string, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_6_decode_string}, {"get_port_count", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_9get_port_count, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_8get_port_count}, {"get_port_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_11get_port_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_10get_port_name}, {"get_ports", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_13get_ports, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_12get_ports}, {"is_port_open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_15is_port_open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_14is_port_open}, {"open_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_17open_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_16open_port}, {"open_virtual_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_19open_virtual_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_18open_virtual_port}, {"close_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_21close_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_20close_port}, {"set_client_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_23set_client_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_22set_client_name}, {"set_port_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_25set_port_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_24set_port_name}, {"set_error_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_27set_error_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_26set_error_callback}, {"cancel_error_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_29cancel_error_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_28cancel_error_callback}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_30__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_8MidiBase_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_8MidiBase_32__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_7_rtmidi_MidiBase_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7_rtmidi_MidiBase}, {Py_tp_traverse, (void *)__pyx_tp_traverse_7_rtmidi_MidiBase}, {Py_tp_clear, (void *)__pyx_tp_clear_7_rtmidi_MidiBase}, {Py_tp_methods, (void *)__pyx_methods_7_rtmidi_MidiBase}, {Py_tp_new, (void *)__pyx_tp_new_7_rtmidi_MidiBase}, {0, 0}, }; static PyType_Spec __pyx_type_7_rtmidi_MidiBase_spec = { "_rtmidi.MidiBase", sizeof(struct __pyx_obj_7_rtmidi_MidiBase), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type_7_rtmidi_MidiBase_slots, }; #else static PyTypeObject __pyx_type_7_rtmidi_MidiBase = { PyVarObject_HEAD_INIT(0, 0) "_rtmidi.""MidiBase", /*tp_name*/ sizeof(struct __pyx_obj_7_rtmidi_MidiBase), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_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_7_rtmidi_MidiBase, /*tp_traverse*/ __pyx_tp_clear_7_rtmidi_MidiBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_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*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_7_rtmidi_MidiIn __pyx_vtable_7_rtmidi_MidiIn; static PyObject *__pyx_tp_new_7_rtmidi_MidiIn(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_7_rtmidi_MidiIn *p; PyObject *o = __pyx_tp_new_7_rtmidi_MidiBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_7_rtmidi_MidiIn *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_7_rtmidi_MidiBase*)__pyx_vtabptr_7_rtmidi_MidiIn; p->_callback = Py_None; Py_INCREF(Py_None); if (unlikely(__pyx_pw_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_7_rtmidi_MidiIn(PyObject *o) { struct __pyx_obj_7_rtmidi_MidiIn *p = (struct __pyx_obj_7_rtmidi_MidiIn *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7_rtmidi_MidiIn) { 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_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_7_rtmidi_MidiBase(o); } static int __pyx_tp_traverse_7_rtmidi_MidiIn(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7_rtmidi_MidiIn *p = (struct __pyx_obj_7_rtmidi_MidiIn *)o; e = __pyx_tp_traverse_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_7_rtmidi_MidiIn(PyObject *o) { PyObject* tmp; struct __pyx_obj_7_rtmidi_MidiIn *p = (struct __pyx_obj_7_rtmidi_MidiIn *)o; __pyx_tp_clear_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_7_rtmidi_6MidiIn_is_deleted(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7_rtmidi_6MidiIn_10is_deleted_1__get__(o); } static PyMethodDef __pyx_methods_7_rtmidi_MidiIn[] = { {"get_current_api", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_3get_current_api, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_2get_current_api}, {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_7delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_6delete}, {"cancel_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_9cancel_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_8cancel_callback}, {"close_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_11close_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_10close_port}, {"get_message", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_13get_message, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_12get_message}, {"ignore_types", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_15ignore_types, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_14ignore_types}, {"set_callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_17set_callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_16set_callback}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_18__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_6MidiIn_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_6MidiIn_20__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7_rtmidi_MidiIn[] = { {(char *)"is_deleted", __pyx_getprop_7_rtmidi_6MidiIn_is_deleted, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_7_rtmidi_MidiIn_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7_rtmidi_MidiIn}, {Py_tp_doc, (void *)PyDoc_STR("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 a (unicode) str or UTF-8 encoded bytes.\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 ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_7_rtmidi_MidiIn}, {Py_tp_clear, (void *)__pyx_tp_clear_7_rtmidi_MidiIn}, {Py_tp_methods, (void *)__pyx_methods_7_rtmidi_MidiIn}, {Py_tp_getset, (void *)__pyx_getsets_7_rtmidi_MidiIn}, {Py_tp_new, (void *)__pyx_tp_new_7_rtmidi_MidiIn}, {0, 0}, }; static PyType_Spec __pyx_type_7_rtmidi_MidiIn_spec = { "_rtmidi.MidiIn", sizeof(struct __pyx_obj_7_rtmidi_MidiIn), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type_7_rtmidi_MidiIn_slots, }; #else static PyTypeObject __pyx_type_7_rtmidi_MidiIn = { PyVarObject_HEAD_INIT(0, 0) "_rtmidi.""MidiIn", /*tp_name*/ sizeof(struct __pyx_obj_7_rtmidi_MidiIn), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_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*/ PyDoc_STR("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 a (unicode) str or UTF-8 encoded bytes.\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_7_rtmidi_MidiIn, /*tp_traverse*/ __pyx_tp_clear_7_rtmidi_MidiIn, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7_rtmidi_MidiIn, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7_rtmidi_MidiIn, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_7_rtmidi_MidiOut __pyx_vtable_7_rtmidi_MidiOut; static PyObject *__pyx_tp_new_7_rtmidi_MidiOut(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_7_rtmidi_MidiOut *p; PyObject *o = __pyx_tp_new_7_rtmidi_MidiBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_7_rtmidi_MidiOut *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_7_rtmidi_MidiBase*)__pyx_vtabptr_7_rtmidi_MidiOut; if (unlikely(__pyx_pw_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_7_rtmidi_MidiOut(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7_rtmidi_MidiOut) { 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_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_7_rtmidi_MidiBase(o); } static PyObject *__pyx_getprop_7_rtmidi_7MidiOut_is_deleted(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7_rtmidi_7MidiOut_10is_deleted_1__get__(o); } static PyMethodDef __pyx_methods_7_rtmidi_MidiOut[] = { {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_4delete}, {"get_current_api", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_7get_current_api, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_6get_current_api}, {"send_message", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_9send_message, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_8send_message}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_10__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7_rtmidi_7MidiOut_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7_rtmidi_7MidiOut_12__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7_rtmidi_MidiOut[] = { {(char *)"is_deleted", __pyx_getprop_7_rtmidi_7MidiOut_is_deleted, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_7_rtmidi_MidiOut_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7_rtmidi_MidiOut}, {Py_tp_doc, (void *)PyDoc_STR("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 a (unicode) str or UTF-8 encoded bytes.\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 ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_7_rtmidi_MidiBase}, {Py_tp_clear, (void *)__pyx_tp_clear_7_rtmidi_MidiBase}, {Py_tp_methods, (void *)__pyx_methods_7_rtmidi_MidiOut}, {Py_tp_getset, (void *)__pyx_getsets_7_rtmidi_MidiOut}, {Py_tp_new, (void *)__pyx_tp_new_7_rtmidi_MidiOut}, {0, 0}, }; static PyType_Spec __pyx_type_7_rtmidi_MidiOut_spec = { "_rtmidi.MidiOut", sizeof(struct __pyx_obj_7_rtmidi_MidiOut), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type_7_rtmidi_MidiOut_slots, }; #else static PyTypeObject __pyx_type_7_rtmidi_MidiOut = { PyVarObject_HEAD_INIT(0, 0) "_rtmidi.""MidiOut", /*tp_name*/ sizeof(struct __pyx_obj_7_rtmidi_MidiOut), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_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*/ PyDoc_STR("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 a (unicode) str or UTF-8 encoded bytes.\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_7_rtmidi_MidiBase, /*tp_traverse*/ __pyx_tp_clear_7_rtmidi_MidiBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7_rtmidi_MidiOut, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7_rtmidi_MidiOut, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #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 /* #### Code section: pystring_table ### */ static int __Pyx_CreateStringTabAndInitStrings(void) { __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_WEB_MIDI, __pyx_k_API_WEB_MIDI, sizeof(__pyx_k_API_WEB_MIDI), 0, 0, 1, 1}, {&__pyx_n_u_API_WEB_MIDI, __pyx_k_API_WEB_MIDI, sizeof(__pyx_k_API_WEB_MIDI), 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_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 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_MidiBase___enter, __pyx_k_MidiBase___enter, sizeof(__pyx_k_MidiBase___enter), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase___exit, __pyx_k_MidiBase___exit, sizeof(__pyx_k_MidiBase___exit), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase___reduce_cython, __pyx_k_MidiBase___reduce_cython, sizeof(__pyx_k_MidiBase___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase___setstate_cython, __pyx_k_MidiBase___setstate_cython, sizeof(__pyx_k_MidiBase___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase__check_port, __pyx_k_MidiBase__check_port, sizeof(__pyx_k_MidiBase__check_port), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase__decode_string, __pyx_k_MidiBase__decode_string, sizeof(__pyx_k_MidiBase__decode_string), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_cancel_error_callback, __pyx_k_MidiBase_cancel_error_callback, sizeof(__pyx_k_MidiBase_cancel_error_callback), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_close_port, __pyx_k_MidiBase_close_port, sizeof(__pyx_k_MidiBase_close_port), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_get_port_count, __pyx_k_MidiBase_get_port_count, sizeof(__pyx_k_MidiBase_get_port_count), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_get_port_name, __pyx_k_MidiBase_get_port_name, sizeof(__pyx_k_MidiBase_get_port_name), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_get_ports, __pyx_k_MidiBase_get_ports, sizeof(__pyx_k_MidiBase_get_ports), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_is_port_open, __pyx_k_MidiBase_is_port_open, sizeof(__pyx_k_MidiBase_is_port_open), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_open_port, __pyx_k_MidiBase_open_port, sizeof(__pyx_k_MidiBase_open_port), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_open_virtual_port, __pyx_k_MidiBase_open_virtual_port, sizeof(__pyx_k_MidiBase_open_virtual_port), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_set_client_name, __pyx_k_MidiBase_set_client_name, sizeof(__pyx_k_MidiBase_set_client_name), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_set_error_callback, __pyx_k_MidiBase_set_error_callback, sizeof(__pyx_k_MidiBase_set_error_callback), 0, 0, 1, 1}, {&__pyx_n_s_MidiBase_set_port_name, __pyx_k_MidiBase_set_port_name, sizeof(__pyx_k_MidiBase_set_port_name), 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_MidiIn___reduce_cython, __pyx_k_MidiIn___reduce_cython, sizeof(__pyx_k_MidiIn___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn___setstate_cython, __pyx_k_MidiIn___setstate_cython, sizeof(__pyx_k_MidiIn___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_cancel_callback, __pyx_k_MidiIn_cancel_callback, sizeof(__pyx_k_MidiIn_cancel_callback), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_close_port, __pyx_k_MidiIn_close_port, sizeof(__pyx_k_MidiIn_close_port), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_delete, __pyx_k_MidiIn_delete, sizeof(__pyx_k_MidiIn_delete), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_get_current_api, __pyx_k_MidiIn_get_current_api, sizeof(__pyx_k_MidiIn_get_current_api), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_get_message, __pyx_k_MidiIn_get_message, sizeof(__pyx_k_MidiIn_get_message), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_ignore_types, __pyx_k_MidiIn_ignore_types, sizeof(__pyx_k_MidiIn_ignore_types), 0, 0, 1, 1}, {&__pyx_n_s_MidiIn_set_callback, __pyx_k_MidiIn_set_callback, sizeof(__pyx_k_MidiIn_set_callback), 0, 0, 1, 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_MidiOut___reduce_cython, __pyx_k_MidiOut___reduce_cython, sizeof(__pyx_k_MidiOut___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiOut___setstate_cython, __pyx_k_MidiOut___setstate_cython, sizeof(__pyx_k_MidiOut___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_MidiOut_delete, __pyx_k_MidiOut_delete, sizeof(__pyx_k_MidiOut_delete), 0, 0, 1, 1}, {&__pyx_n_s_MidiOut_get_current_api, __pyx_k_MidiOut_get_current_api, sizeof(__pyx_k_MidiOut_get_current_api), 0, 0, 1, 1}, {&__pyx_n_s_MidiOut_send_message, __pyx_k_MidiOut_send_message, sizeof(__pyx_k_MidiOut_send_message), 0, 0, 1, 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__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 1}, {&__pyx_n_s__77, __pyx_k__77, sizeof(__pyx_k__77), 0, 0, 1, 1}, {&__pyx_kp_u__9, __pyx_k__9, sizeof(__pyx_k__9), 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_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, {&__pyx_n_u_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 1, 0, 1}, {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, {&__pyx_n_s_cancel_callback, __pyx_k_cancel_callback, sizeof(__pyx_k_cancel_callback), 0, 0, 1, 1}, {&__pyx_n_s_cancel_error_callback, __pyx_k_cancel_error_callback, sizeof(__pyx_k_cancel_error_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_delete, __pyx_k_delete, sizeof(__pyx_k_delete), 0, 0, 1, 1}, {&__pyx_n_s_delta_time, __pyx_k_delta_time, sizeof(__pyx_k_delta_time), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, {&__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_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 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_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1}, {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, {&__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_message, __pyx_k_get_message, sizeof(__pyx_k_get_message), 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_ports, __pyx_k_get_ports, sizeof(__pyx_k_get_ports), 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_kp_s_home_runner_work_python_rtmidi, __pyx_k_home_runner_work_python_rtmidi, sizeof(__pyx_k_home_runner_work_python_rtmidi), 0, 0, 1, 0}, {&__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_ignore_types, __pyx_k_ignore_types, sizeof(__pyx_k_ignore_types), 0, 0, 1, 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_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1}, {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, {&__pyx_n_s_inout, __pyx_k_inout, sizeof(__pyx_k_inout), 0, 0, 1, 1}, {&__pyx_n_u_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 1, 0, 1}, {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, {&__pyx_kp_u_is_invalid, __pyx_k_is_invalid, sizeof(__pyx_k_is_invalid), 0, 1, 0, 0}, {&__pyx_n_s_is_port_open, __pyx_k_is_port_open, sizeof(__pyx_k_is_port_open), 0, 0, 1, 1}, {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 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_n_s_message, __pyx_k_message, sizeof(__pyx_k_message), 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_mro_entries, __pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 0, 1, 1}, {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, {&__pyx_n_s_msg_v, __pyx_k_msg_v, sizeof(__pyx_k_msg_v), 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_a_bytes_instance, __pyx_k_name_must_be_a_bytes_instance, sizeof(__pyx_k_name_must_be_a_bytes_instance), 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_s_open_port, __pyx_k_open_port, sizeof(__pyx_k_open_port), 0, 0, 1, 1}, {&__pyx_n_s_open_virtual_port, __pyx_k_open_virtual_port, sizeof(__pyx_k_open_virtual_port), 0, 0, 1, 1}, {&__pyx_n_u_output, __pyx_k_output, sizeof(__pyx_k_output), 0, 1, 0, 1}, {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 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, __pyx_k_rtmidi, sizeof(__pyx_k_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_send_message, __pyx_k_send_message, sizeof(__pyx_k_send_message), 0, 0, 1, 1}, {&__pyx_n_s_set_callback, __pyx_k_set_callback, sizeof(__pyx_k_set_callback), 0, 0, 1, 1}, {&__pyx_n_s_set_client_name, __pyx_k_set_client_name, sizeof(__pyx_k_set_client_name), 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_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, {&__pyx_n_s_set_port_name, __pyx_k_set_port_name, sizeof(__pyx_k_set_port_name), 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_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 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_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 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} }; return __Pyx_InitStrings(__pyx_string_tab); } /* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 277, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 286, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 295, __pyx_L1_error) __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(0, 304, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 210, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 227, __pyx_L1_error) __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_n_s_super); if (!__pyx_builtin_super) __PYX_ERR(0, 273, __pyx_L1_error) __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 637, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "_rtmidi.pyx":227 * * if not isinstance(name, bytes): * raise TypeError("name must be a bytes instance.") # <<<<<<<<<<<<<< * * return name */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_name_must_be_a_bytes_instance); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "_rtmidi.pyx":637 * """ * 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, 637, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "_rtmidi.pyx":681 * """ * 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, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "_rtmidi.pyx":1101 * * if msg_v.size() == 0: * raise ValueError("'message' must not be empty.") # <<<<<<<<<<<<<< * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_message_must_not_be_empty); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 1101, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "_rtmidi.pyx":1103 * raise ValueError("'message' must not be empty.") * elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: * raise ValueError("'message' longer than 3 bytes but does not " # <<<<<<<<<<<<<< * "start with 0xF0.") * */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_message_longer_than_3_bytes_but); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 1103, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x2133db3, 0x021d8b9, 0x9171c0f): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x2133db3, 0x021d8b9, 0x9171c0f) = (_deleted, _error_callback, _port))" % __pyx_checksum */ __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_34815411, __pyx_int_2218169, __pyx_int_152509455); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "_rtmidi.pyx":118 * * __all__ = ( * 'API_UNSPECIFIED', 'API_MACOSX_CORE', 'API_LINUX_ALSA', 'API_UNIX_JACK', # <<<<<<<<<<<<<< * 'API_WINDOWS_MM', 'API_RTMIDI_DUMMY', 'API_WEB_MIDI', 'ERRORTYPE_DEBUG_WARNING', * 'ERRORTYPE_DRIVER_ERROR', 'ERRORTYPE_INVALID_DEVICE', */ __pyx_tuple__11 = PyTuple_Pack(32, __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_API_WEB_MIDI, __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__11)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "_rtmidi.pyx":221 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a str object into bytes.""" * if isinstance(name, str): */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_name); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_to_bytes, 221, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 221, __pyx_L1_error) /* "_rtmidi.pyx":272 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ __pyx_tuple__14 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_msg, __pyx_n_s_type); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_init, 272, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 272, __pyx_L1_error) __pyx_tuple__16 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "_rtmidi.pyx":333 * # 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__17 = PyTuple_Pack(1, __pyx_n_s_api); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_api_display_name, 333, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 333, __pyx_L1_error) /* "_rtmidi.pyx":349 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_api_name, 349, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 349, __pyx_L1_error) /* "_rtmidi.pyx":365 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ __pyx_tuple__20 = PyTuple_Pack(2, __pyx_n_s_api_v, __pyx_n_s_i); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 2, 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_home_runner_work_python_rtmidi, __pyx_n_s_get_compiled_api, 365, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 365, __pyx_L1_error) /* "_rtmidi.pyx":381 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_compiled_api_by_name, 381, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 381, __pyx_L1_error) /* "_rtmidi.pyx":392 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(0, 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_home_runner_work_python_rtmidi, __pyx_n_s_get_rtmidi_version, 392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 392, __pyx_L1_error) /* "_rtmidi.pyx":397 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ __pyx_tuple__24 = PyTuple_Pack(3, __pyx_n_s_etype, __pyx_n_s_msg, __pyx_n_s_data); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 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_home_runner_work_python_rtmidi, __pyx_n_s_default_error_handler, 397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 397, __pyx_L1_error) /* "_rtmidi.pyx":435 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ __pyx_tuple__26 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_enter, 435, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 435, __pyx_L1_error) /* "_rtmidi.pyx":463 * return self * * def __exit__(self, *exc_info): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ __pyx_tuple__28 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_exc_info); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 463, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_exit, 463, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 463, __pyx_L1_error) /* "_rtmidi.pyx":472 * self.close_port() * * def _check_port(self): # <<<<<<<<<<<<<< * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: */ __pyx_tuple__30 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_inout); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_check_port, 472, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 472, __pyx_L1_error) /* "_rtmidi.pyx":482 * return inout * * def _decode_string(self, s, encoding='auto'): # <<<<<<<<<<<<<< * """Decode given byte string with given encoding.""" * if encoding == 'auto': */ __pyx_tuple__32 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_s, __pyx_n_s_encoding); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_decode_string, 482, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 482, __pyx_L1_error) __pyx_tuple__34 = PyTuple_Pack(1, __pyx_n_u_auto); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "_rtmidi.pyx":495 * return s.decode(encoding, "ignore") * * def get_port_count(self): # <<<<<<<<<<<<<< * """Return the number of available MIDI input or output ports.""" * return self.baseptr().getPortCount() */ __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_port_count, 495, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 495, __pyx_L1_error) /* "_rtmidi.pyx":499 * 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. * */ __pyx_tuple__36 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_port_2, __pyx_n_s_encoding, __pyx_n_s_name); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_port_name, 499, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 499, __pyx_L1_error) /* "_rtmidi.pyx":518 * 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. * */ __pyx_tuple__38 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_encoding, __pyx_n_s_p); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_ports, 518, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 518, __pyx_L1_error) /* "_rtmidi.pyx":533 * 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. * */ __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_is_port_open, 533, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 533, __pyx_L1_error) /* "_rtmidi.pyx":544 * 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. * */ __pyx_tuple__41 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_port_2, __pyx_n_s_name, __pyx_n_s_inout); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_open_port, 544, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 544, __pyx_L1_error) __pyx_tuple__43 = PyTuple_Pack(2, __pyx_int_0, Py_None); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "_rtmidi.pyx":585 * return self * * def open_virtual_port(self, name=None): # <<<<<<<<<<<<<< * """Open a virtual MIDI input or output port. * */ __pyx_tuple__44 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_inout); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_open_virtual_port, 585, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 585, __pyx_L1_error) /* "_rtmidi.pyx":646 * return self * * def close_port(self): # <<<<<<<<<<<<<< * """Close the MIDI input or output port opened via ``open_port``. * */ __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_close_port, 646, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 646, __pyx_L1_error) /* "_rtmidi.pyx":662 * self.baseptr().closePort() * * def set_client_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the MIDI client. * */ __pyx_tuple__47 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_name); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 662, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_set_client_name, 662, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 662, __pyx_L1_error) /* "_rtmidi.pyx":686 * self.baseptr().setClientName(_to_bytes(name)) * * def set_port_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the currently opened port. * */ __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_set_port_name, 686, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 686, __pyx_L1_error) /* "_rtmidi.pyx":715 * self.baseptr().setPortName(_to_bytes(name)) * * def set_error_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for errors. * */ __pyx_tuple__50 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_func, __pyx_n_s_data); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__50); __Pyx_GIVEREF(__pyx_tuple__50); __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_set_error_callback, 715, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 715, __pyx_L1_error) /* "_rtmidi.pyx":742 * self._error_callback) * * def cancel_error_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for errors. * */ __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_cancel_error_callback, 742, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(0, 742, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ __pyx_tuple__53 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(1, 1, __pyx_L1_error) /* "(tree fragment)":16 * else: * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ __pyx_tuple__55 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(1, 16, __pyx_L1_error) /* "_rtmidi.pyx":819 * self._deleted = False * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_current_api, 819, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 819, __pyx_L1_error) /* "_rtmidi.pyx":838 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_delete, 838, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(0, 838, __pyx_L1_error) /* "_rtmidi.pyx":863 * return self._deleted * * def cancel_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for MIDI input. * */ __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_cancel_callback, 863, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 863, __pyx_L1_error) /* "_rtmidi.pyx":874 * self._callback = None * * def close_port(self): # <<<<<<<<<<<<<< * self.cancel_callback() * MidiBase.close_port(self) */ __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_close_port, 874, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(0, 874, __pyx_L1_error) /* "_rtmidi.pyx":880 * close_port.__doc__ == MidiBase.close_port.__doc__ * * def get_message(self): # <<<<<<<<<<<<<< * """Poll for MIDI input. * */ __pyx_tuple__61 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_msg_v, __pyx_n_s_delta_time, __pyx_n_s_message, __pyx_n_s_i); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__61, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_message, 880, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(0, 880, __pyx_L1_error) /* "_rtmidi.pyx":900 * 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. * */ __pyx_tuple__63 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_sysex, __pyx_n_s_timing, __pyx_n_s_active_sense); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 900, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_ignore_types, 900, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 900, __pyx_L1_error) __pyx_tuple__65 = PyTuple_Pack(3, Py_True, Py_True, Py_True); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 900, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "_rtmidi.pyx":938 * self.thisptr.ignoreTypes(sysex, timing, active_sense) * * def set_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for MIDI input. * */ __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_set_callback, 938, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(0, 938, __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): */ __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(1, 1, __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__" */ __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(1, 3, __pyx_L1_error) /* "_rtmidi.pyx":1027 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_delete, 1027, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 1027, __pyx_L1_error) /* "_rtmidi.pyx":1052 * return self._deleted * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_get_current_api, 1052, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 1052, __pyx_L1_error) /* "_rtmidi.pyx":1066 * return self.thisptr.getCurrentApi() * * def send_message(self, message): # <<<<<<<<<<<<<< * """Send a MIDI message to the output port. * */ __pyx_tuple__71 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_message, __pyx_n_s_msg_v, __pyx_n_s_c); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 1066, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_runner_work_python_rtmidi, __pyx_n_s_send_message, 1066, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(0, 1066, __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): */ __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(1, 1, __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__" */ __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(1, 3, __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__75 = 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__75)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_MidiBase, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } /* #### Code section: init_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2218169 = PyInt_FromLong(2218169L); if (unlikely(!__pyx_int_2218169)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_34815411 = PyInt_FromLong(34815411L); if (unlikely(!__pyx_int_34815411)) __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; } /* #### Code section: init_globals ### */ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { return 0; } /* #### Code section: init_module ### */ 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 PyObject *__pyx_t_1 = NULL; 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_7_rtmidi_MidiBase = &__pyx_vtable_7_rtmidi_MidiBase; __pyx_vtable_7_rtmidi_MidiBase.baseptr = (RtMidi *(*)(struct __pyx_obj_7_rtmidi_MidiBase *))__pyx_f_7_rtmidi_8MidiBase_baseptr; #if CYTHON_USE_TYPE_SPECS __pyx_ptype_7_rtmidi_MidiBase = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7_rtmidi_MidiBase_spec, NULL); if (unlikely(!__pyx_ptype_7_rtmidi_MidiBase)) __PYX_ERR(0, 426, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7_rtmidi_MidiBase_spec, __pyx_ptype_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #else __pyx_ptype_7_rtmidi_MidiBase = &__pyx_type_7_rtmidi_MidiBase; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_7_rtmidi_MidiBase->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7_rtmidi_MidiBase->tp_dictoffset && __pyx_ptype_7_rtmidi_MidiBase->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_7_rtmidi_MidiBase->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_7_rtmidi_MidiBase, __pyx_vtabptr_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiBase, (PyObject *) __pyx_ptype_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7_rtmidi_MidiBase) < 0) __PYX_ERR(0, 426, __pyx_L1_error) #endif __pyx_vtabptr_7_rtmidi_MidiIn = &__pyx_vtable_7_rtmidi_MidiIn; __pyx_vtable_7_rtmidi_MidiIn.__pyx_base = *__pyx_vtabptr_7_rtmidi_MidiBase; __pyx_vtable_7_rtmidi_MidiIn.__pyx_base.baseptr = (RtMidi *(*)(struct __pyx_obj_7_rtmidi_MidiBase *))__pyx_f_7_rtmidi_6MidiIn_baseptr; #if CYTHON_USE_TYPE_SPECS __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_7_rtmidi_MidiBase); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7_rtmidi_MidiIn = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7_rtmidi_MidiIn_spec, __pyx_t_1); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_ptype_7_rtmidi_MidiIn)) __PYX_ERR(0, 752, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7_rtmidi_MidiIn_spec, __pyx_ptype_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #else __pyx_ptype_7_rtmidi_MidiIn = &__pyx_type_7_rtmidi_MidiIn; #endif #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_ptype_7_rtmidi_MidiIn->tp_base = __pyx_ptype_7_rtmidi_MidiBase; #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_7_rtmidi_MidiIn->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7_rtmidi_MidiIn->tp_dictoffset && __pyx_ptype_7_rtmidi_MidiIn->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_7_rtmidi_MidiIn->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_7_rtmidi_MidiIn, __pyx_vtabptr_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiIn, (PyObject *) __pyx_ptype_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7_rtmidi_MidiIn) < 0) __PYX_ERR(0, 752, __pyx_L1_error) #endif __pyx_vtabptr_7_rtmidi_MidiOut = &__pyx_vtable_7_rtmidi_MidiOut; __pyx_vtable_7_rtmidi_MidiOut.__pyx_base = *__pyx_vtabptr_7_rtmidi_MidiBase; __pyx_vtable_7_rtmidi_MidiOut.__pyx_base.baseptr = (RtMidi *(*)(struct __pyx_obj_7_rtmidi_MidiBase *))__pyx_f_7_rtmidi_7MidiOut_baseptr; #if CYTHON_USE_TYPE_SPECS __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_7_rtmidi_MidiBase); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 964, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7_rtmidi_MidiOut = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7_rtmidi_MidiOut_spec, __pyx_t_1); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_ptype_7_rtmidi_MidiOut)) __PYX_ERR(0, 964, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7_rtmidi_MidiOut_spec, __pyx_ptype_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #else __pyx_ptype_7_rtmidi_MidiOut = &__pyx_type_7_rtmidi_MidiOut; #endif #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_ptype_7_rtmidi_MidiOut->tp_base = __pyx_ptype_7_rtmidi_MidiBase; #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_7_rtmidi_MidiOut->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7_rtmidi_MidiOut->tp_dictoffset && __pyx_ptype_7_rtmidi_MidiOut->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_7_rtmidi_MidiOut->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_7_rtmidi_MidiOut, __pyx_vtabptr_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MidiOut, (PyObject *) __pyx_ptype_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7_rtmidi_MidiOut) < 0) __PYX_ERR(0, 964, __pyx_L1_error) #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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; } #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 #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "_rtmidi", __pyx_k_A_Python_binding_for_the_RtMidi, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #elif CYTHON_USE_MODULE_STATE sizeof(__pyx_mstate), /* 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 #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif #endif #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; } #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) #else 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) #endif { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { #if CYTHON_COMPILING_IN_LIMITED_API result = PyModule_AddObject(module, to_name, value); #else result = PyDict_SetItemString(moddict, to_name, value); #endif } 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, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); 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; #if CYTHON_COMPILING_IN_LIMITED_API moddict = module; #else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; #endif 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 { int stringtab_initialized = 0; #if CYTHON_USE_MODULE_STATE int pystate_addmodule_run = 0; #endif 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 = 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 /*--- 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); if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #elif CYTHON_USE_MODULE_STATE __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) { int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to _rtmidi pseudovariable */ if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else __pyx_m = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif #endif CYTHON_UNUSED_VAR(__pyx_t_1); __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #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(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 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(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; 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) { 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")) { if (unlikely((PyDict_SetItemString(modules, "_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 /* "_rtmidi.pyx":109 * """ * * import sys # <<<<<<<<<<<<<< * import warnings * */ __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_sys, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 109, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":110 * * import sys * import warnings # <<<<<<<<<<<<<< * * from libcpp cimport bool */ __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_warnings, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":118 * * __all__ = ( * 'API_UNSPECIFIED', 'API_MACOSX_CORE', 'API_LINUX_ALSA', 'API_UNIX_JACK', # <<<<<<<<<<<<<< * 'API_WINDOWS_MM', 'API_RTMIDI_DUMMY', 'API_WEB_MIDI', 'ERRORTYPE_DEBUG_WARNING', * 'ERRORTYPE_DRIVER_ERROR', 'ERRORTYPE_INVALID_DEVICE', */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__11) < 0) __PYX_ERR(0, 117, __pyx_L1_error) /* "_rtmidi.pyx":134 * void Py_Initialize() * * Py_Initialize() # <<<<<<<<<<<<<< * * # Declarations for RtMidi C++ classes and their methods we use */ Py_Initialize(); /* "_rtmidi.pyx":221 * * * def _to_bytes(name): # <<<<<<<<<<<<<< * """Convert a str object into bytes.""" * if isinstance(name, str): */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_1_to_bytes, 0, __pyx_n_s_to_bytes, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_to_bytes, __pyx_t_2) < 0) __PYX_ERR(0, 221, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":236 * # export Api enum values to Python * * API_UNSPECIFIED = UNSPECIFIED # <<<<<<<<<<<<<< * API_MACOSX_CORE = MACOSX_CORE * API_LINUX_ALSA = LINUX_ALSA */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::UNSPECIFIED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_UNSPECIFIED, __pyx_t_2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":237 * * API_UNSPECIFIED = UNSPECIFIED * API_MACOSX_CORE = MACOSX_CORE # <<<<<<<<<<<<<< * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::MACOSX_CORE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_MACOSX_CORE, __pyx_t_2) < 0) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":238 * 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_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::LINUX_ALSA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_LINUX_ALSA, __pyx_t_2) < 0) __PYX_ERR(0, 238, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":239 * API_MACOSX_CORE = MACOSX_CORE * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK # <<<<<<<<<<<<<< * API_WINDOWS_MM = WINDOWS_MM * API_WEB_MIDI = WEB_MIDI */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::UNIX_JACK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_UNIX_JACK, __pyx_t_2) < 0) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":240 * API_LINUX_ALSA = LINUX_ALSA * API_UNIX_JACK = UNIX_JACK * API_WINDOWS_MM = WINDOWS_MM # <<<<<<<<<<<<<< * API_WEB_MIDI = WEB_MIDI * API_RTMIDI_DUMMY = RTMIDI_DUMMY */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::WINDOWS_MM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_WINDOWS_MM, __pyx_t_2) < 0) __PYX_ERR(0, 240, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":241 * API_UNIX_JACK = UNIX_JACK * API_WINDOWS_MM = WINDOWS_MM * API_WEB_MIDI = WEB_MIDI # <<<<<<<<<<<<<< * API_RTMIDI_DUMMY = RTMIDI_DUMMY * */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::WEB_MIDI_API); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_WEB_MIDI, __pyx_t_2) < 0) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":242 * API_WINDOWS_MM = WINDOWS_MM * API_WEB_MIDI = WEB_MIDI * API_RTMIDI_DUMMY = RTMIDI_DUMMY # <<<<<<<<<<<<<< * * # export error values to Python */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidi_3a__3a_Api(RtMidi::RTMIDI_DUMMY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_API_RTMIDI_DUMMY, __pyx_t_2) < 0) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":246 * # export error values to Python * * ERRORTYPE_WARNING = ERR_WARNING # <<<<<<<<<<<<<< * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::WARNING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_WARNING, __pyx_t_2) < 0) __PYX_ERR(0, 246, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":247 * * ERRORTYPE_WARNING = ERR_WARNING * ERRORTYPE_DEBUG_WARNING = ERR_DEBUG_WARNING # <<<<<<<<<<<<<< * ERRORTYPE_UNSPECIFIED = ERR_UNSPECIFIED * ERRORTYPE_NO_DEVICES_FOUND = ERR_NO_DEVICES_FOUND */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DEBUG_WARNING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_DEBUG_WARNING, __pyx_t_2) < 0) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":248 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::UNSPECIFIED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_UNSPECIFIED, __pyx_t_2) < 0) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":249 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::NO_DEVICES_FOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_NO_DEVICES_FOUND, __pyx_t_2) < 0) __PYX_ERR(0, 249, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":250 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_DEVICE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_DEVICE, __pyx_t_2) < 0) __PYX_ERR(0, 250, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":251 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::MEMORY_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_MEMORY_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":252 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_PARAMETER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_PARAMETER, __pyx_t_2) < 0) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":253 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_USE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_INVALID_USE, __pyx_t_2) < 0) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":254 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::DRIVER_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_DRIVER_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 254, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":255 * 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_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::SYSTEM_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_SYSTEM_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":256 * ERRORTYPE_DRIVER_ERROR = ERR_DRIVER_ERROR * ERRORTYPE_SYSTEM_ERROR = ERR_SYSTEM_ERROR * ERRORTYPE_THREAD_ERROR = ERR_THREAD_ERROR # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::THREAD_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERRORTYPE_THREAD_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_rtmidi.pyx":261 * # custom exceptions * * class RtMidiError(Exception): # <<<<<<<<<<<<<< * """Base general RtMidi exception. * */ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 261, __pyx_L1_error); __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_RtMidiError, __pyx_n_s_RtMidiError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Base_general_RtMidi_exception_Al); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3 != __pyx_t_2) { if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 261, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_rtmidi.pyx":270 * * """ * type = ERR_UNSPECIFIED # <<<<<<<<<<<<<< * * def __init__(self, msg, type=None): */ __pyx_t_6 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::UNSPECIFIED); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_6) < 0) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_rtmidi.pyx":272 * type = ERR_UNSPECIFIED * * def __init__(self, msg, type=None): # <<<<<<<<<<<<<< * super().__init__(msg) * self.type = self.type if type is None else type */ __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_11RtMidiError_1__init__, 0, __pyx_n_s_RtMidiError___init, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_6); PyList_Append(__pyx_t_2, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_tuple__16); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_init, __pyx_t_6) < 0) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_rtmidi.pyx":261 * # custom exceptions * * class RtMidiError(Exception): # <<<<<<<<<<<<<< * """Base general RtMidi exception. * */ __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_RtMidiError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__Pyx_CyFunction_InitClassCell(__pyx_t_2, __pyx_t_6) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_RtMidiError, __pyx_t_6) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":277 * * * class InvalidPortError(RtMidiError, ValueError): # <<<<<<<<<<<<<< * """Raised when an invalid port number is used. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error); __Pyx_INCREF(__pyx_builtin_ValueError); __Pyx_GIVEREF(__pyx_builtin_ValueError); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_builtin_ValueError)) __PYX_ERR(0, 277, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_InvalidPortError, __pyx_n_s_InvalidPortError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_when_an_invalid_port_numb); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_3 != __pyx_t_4) { if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 277, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_rtmidi.pyx":283 * * """ * type = ERR_INVALID_PARAMETER # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_PARAMETER); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_n_s_type, __pyx_t_4) < 0) __PYX_ERR(0, 283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_rtmidi.pyx":277 * * * class InvalidPortError(RtMidiError, ValueError): # <<<<<<<<<<<<<< * """Raised when an invalid port number is used. * */ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_InvalidPortError, __pyx_t_3, __pyx_t_6, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidPortError, __pyx_t_4) < 0) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":286 * * * class InvalidUseError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised when an method call is not allowed in the current state. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error); __Pyx_INCREF(__pyx_builtin_RuntimeError); __Pyx_GIVEREF(__pyx_builtin_RuntimeError); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_builtin_RuntimeError)) __PYX_ERR(0, 286, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_3, __pyx_n_s_InvalidUseError, __pyx_n_s_InvalidUseError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_when_an_method_call_is_no); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3 != __pyx_t_5) { if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 286, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_rtmidi.pyx":292 * * """ * type = ERR_INVALID_USE # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::INVALID_USE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_type, __pyx_t_5) < 0) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_rtmidi.pyx":286 * * * class InvalidUseError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised when an method call is not allowed in the current state. * */ __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_n_s_InvalidUseError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidUseError, __pyx_t_5) < 0) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":295 * * * class MemoryAllocationError(RtMidiError, MemoryError): # <<<<<<<<<<<<<< * """Raised if a memory allocation failed on the C++ level. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error); __Pyx_INCREF(__pyx_builtin_MemoryError); __Pyx_GIVEREF(__pyx_builtin_MemoryError); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_builtin_MemoryError)) __PYX_ERR(0, 295, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_MemoryAllocationError, __pyx_n_s_MemoryAllocationError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_if_a_memory_allocation_fa); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3 != __pyx_t_6) { if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_6) < 0))) __PYX_ERR(0, 295, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_rtmidi.pyx":301 * * """ * type = ERR_MEMORY_ERROR # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::MEMORY_ERROR); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_type, __pyx_t_6) < 0) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_rtmidi.pyx":295 * * * class MemoryAllocationError(RtMidiError, MemoryError): # <<<<<<<<<<<<<< * """Raised if a memory allocation failed on the C++ level. * */ __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_MemoryAllocationError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MemoryAllocationError, __pyx_t_6) < 0) __PYX_ERR(0, 295, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":304 * * * class SystemError(RtMidiError, OSError): # <<<<<<<<<<<<<< * """Raised if an error happened at the MIDI driver or OS level. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error); __Pyx_INCREF(__pyx_builtin_OSError); __Pyx_GIVEREF(__pyx_builtin_OSError); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_builtin_OSError)) __PYX_ERR(0, 304, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_SystemError, __pyx_n_s_SystemError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_if_an_error_happened_at_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_3 != __pyx_t_4) { if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 304, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SystemError, __pyx_t_3, __pyx_t_6, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SystemError, __pyx_t_4) < 0) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":313 * * * class NoDevicesError(SystemError): # <<<<<<<<<<<<<< * """Raised if no MIDI devices are found. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SystemError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 313, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_3, __pyx_n_s_NoDevicesError, __pyx_n_s_NoDevicesError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_if_no_MIDI_devices_are_fo); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3 != __pyx_t_5) { if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 313, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_rtmidi.pyx":319 * * """ * type = ERR_NO_DEVICES_FOUND # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(RtMidiError::NO_DEVICES_FOUND); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_type, __pyx_t_5) < 0) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_rtmidi.pyx":313 * * * class NoDevicesError(SystemError): # <<<<<<<<<<<<<< * """Raised if no MIDI devices are found. * */ __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_n_s_NoDevicesError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NoDevicesError, __pyx_t_5) < 0) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":322 * * * class UnsupportedOperationError(RtMidiError, RuntimeError): # <<<<<<<<<<<<<< * """Raised if a method is not supported by the low-level API. * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RtMidiError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error); __Pyx_INCREF(__pyx_builtin_RuntimeError); __Pyx_GIVEREF(__pyx_builtin_RuntimeError); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_builtin_RuntimeError)) __PYX_ERR(0, 322, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_UnsupportedOperationError, __pyx_n_s_UnsupportedOperationError, (PyObject *) NULL, __pyx_n_s_rtmidi, __pyx_kp_s_Raised_if_a_method_is_not_suppor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3 != __pyx_t_6) { if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_6) < 0))) __PYX_ERR(0, 322, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_UnsupportedOperationError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnsupportedOperationError, __pyx_t_6) < 0) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":333 * # 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_3get_api_display_name, 0, __pyx_n_s_get_api_display_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_api_display_name, __pyx_t_3) < 0) __PYX_ERR(0, 333, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":349 * * * def get_api_name(api): # <<<<<<<<<<<<<< * """Return the name of a specified MIDI API. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_5get_api_name, 0, __pyx_n_s_get_api_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_api_name, __pyx_t_3) < 0) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":365 * * * def get_compiled_api(): # <<<<<<<<<<<<<< * """Return a list of low-level MIDI backend APIs this module supports. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7get_compiled_api, 0, __pyx_n_s_get_compiled_api, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_compiled_api, __pyx_t_3) < 0) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":381 * * * def get_compiled_api_by_name(name): # <<<<<<<<<<<<<< * """Return the compiled MIDI API having the given name. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_9get_compiled_api_by_name, 0, __pyx_n_s_get_compiled_api_by_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_compiled_api_by_name, __pyx_t_3) < 0) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":392 * * * def get_rtmidi_version(): # <<<<<<<<<<<<<< * """Return the version string of the wrapped RtMidi library.""" * return RtMidi_getVersion().decode('utf-8') */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_11get_rtmidi_version, 0, __pyx_n_s_get_rtmidi_version, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_rtmidi_version, __pyx_t_3) < 0) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":397 * * * def _default_error_handler(etype, msg, data=None): # <<<<<<<<<<<<<< * if etype == ERR_MEMORY_ERROR: * raise MemoryAllocationError(msg) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_13_default_error_handler, 0, __pyx_n_s_default_error_handler, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_error_handler, __pyx_t_3) < 0) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":435 * * # context management * def __enter__(self): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_1__enter__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase___enter, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_enter, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":463 * return self * * def __exit__(self, *exc_info): # <<<<<<<<<<<<<< * """Support context manager protocol. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_3__exit__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase___exit, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_exit, __pyx_t_3) < 0) __PYX_ERR(0, 463, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":472 * self.close_port() * * def _check_port(self): # <<<<<<<<<<<<<< * inout = "input" if isinstance(self, MidiIn) else "output" * if self._port == -1: */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_5_check_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase__check_port, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_check_port, __pyx_t_3) < 0) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":482 * return inout * * def _decode_string(self, s, encoding='auto'): # <<<<<<<<<<<<<< * """Decode given byte string with given encoding.""" * if encoding == 'auto': */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_7_decode_string, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase__decode_string, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__34); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_decode_string, __pyx_t_3) < 0) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":495 * return s.decode(encoding, "ignore") * * def get_port_count(self): # <<<<<<<<<<<<<< * """Return the number of available MIDI input or output ports.""" * return self.baseptr().getPortCount() */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_9get_port_count, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_get_port_count, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_get_port_count, __pyx_t_3) < 0) __PYX_ERR(0, 495, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":499 * 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. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_11get_port_name, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_get_port_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__34); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_get_port_name, __pyx_t_3) < 0) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":518 * 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. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_13get_ports, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_get_ports, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__34); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_get_ports, __pyx_t_3) < 0) __PYX_ERR(0, 518, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":533 * 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. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_15is_port_open, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_is_port_open, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_is_port_open, __pyx_t_3) < 0) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":544 * 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. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_17open_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_open_port, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__43); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_open_port, __pyx_t_3) < 0) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":585 * return self * * def open_virtual_port(self, name=None): # <<<<<<<<<<<<<< * """Open a virtual MIDI input or output port. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_19open_virtual_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_open_virtual_port, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__16); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_open_virtual_port, __pyx_t_3) < 0) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":646 * return self * * def close_port(self): # <<<<<<<<<<<<<< * """Close the MIDI input or output port opened via ``open_port``. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_21close_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_close_port, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_close_port, __pyx_t_3) < 0) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":662 * self.baseptr().closePort() * * def set_client_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the MIDI client. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_23set_client_name, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_set_client_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 662, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_set_client_name, __pyx_t_3) < 0) __PYX_ERR(0, 662, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":686 * self.baseptr().setClientName(_to_bytes(name)) * * def set_port_name(self, name): # <<<<<<<<<<<<<< * """Set the name of the currently opened port. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_25set_port_name, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_set_port_name, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_set_port_name, __pyx_t_3) < 0) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":715 * self.baseptr().setPortName(_to_bytes(name)) * * def set_error_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for errors. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_27set_error_callback, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_set_error_callback, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__16); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_set_error_callback, __pyx_t_3) < 0) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":742 * self._error_callback) * * def cancel_error_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for errors. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_29cancel_error_callback, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase_cancel_error_callback, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_cancel_error_callback, __pyx_t_3) < 0) __PYX_ERR(0, 742, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_31__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase___reduce_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "(tree fragment)":16 * else: * return __pyx_unpickle_MidiBase, (type(self), 0x2133db3, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_MidiBase__set_state(self, __pyx_state) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_8MidiBase_33__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiBase___setstate_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiBase, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 16, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiBase); /* "_rtmidi.pyx":799 * 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; /* "_rtmidi.pyx":819 * self._deleted = False * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_3get_current_api, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_get_current_api, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_get_current_api, __pyx_t_3) < 0) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":838 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_7delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_delete, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 838, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_delete, __pyx_t_3) < 0) __PYX_ERR(0, 838, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":863 * return self._deleted * * def cancel_callback(self): # <<<<<<<<<<<<<< * """Remove the registered callback function for MIDI input. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_9cancel_callback, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_cancel_callback, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__59)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_cancel_callback, __pyx_t_3) < 0) __PYX_ERR(0, 863, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":874 * self._callback = None * * def close_port(self): # <<<<<<<<<<<<<< * self.cancel_callback() * MidiBase.close_port(self) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_11close_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_close_port, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 874, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_close_port, __pyx_t_3) < 0) __PYX_ERR(0, 874, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":878 * MidiBase.close_port(self) * * close_port.__doc__ == MidiBase.close_port.__doc__ # <<<<<<<<<<<<<< * * def get_message(self): */ __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_close_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_doc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7_rtmidi_MidiBase), __pyx_n_s_close_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_doc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 878, __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_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":880 * close_port.__doc__ == MidiBase.close_port.__doc__ * * def get_message(self): # <<<<<<<<<<<<<< * """Poll for MIDI input. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_13get_message, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_get_message, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_get_message, __pyx_t_3) < 0) __PYX_ERR(0, 880, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":900 * 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. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_15ignore_types, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_ignore_types, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 900, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__65); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_ignore_types, __pyx_t_3) < 0) __PYX_ERR(0, 900, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "_rtmidi.pyx":938 * self.thisptr.ignoreTypes(sysex, timing, active_sense) * * def set_callback(self, func, data=None): # <<<<<<<<<<<<<< * """Register a callback function for MIDI input. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_17set_callback, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn_set_callback, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__16); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiIn, __pyx_n_s_set_callback, __pyx_t_3) < 0) __PYX_ERR(0, 938, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiIn); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn___reduce_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__67)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(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__" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_6MidiIn_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiIn___setstate_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":1004 * return self.thisptr * * def __cinit__(self, Api rtapi=UNSPECIFIED, name=None): # <<<<<<<<<<<<<< * """Create a new client instance for MIDI output. * */ __pyx_k__5 = RtMidi::UNSPECIFIED; /* "_rtmidi.pyx":1027 * del self.thisptr * * def delete(self): # <<<<<<<<<<<<<< * """De-allocate pointer to C++ class instance. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7MidiOut_5delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiOut_delete, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__69)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiOut, __pyx_n_s_delete, __pyx_t_3) < 0) __PYX_ERR(0, 1027, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiOut); /* "_rtmidi.pyx":1052 * return self._deleted * * def get_current_api(self): # <<<<<<<<<<<<<< * """Return the low-level MIDI backend API used by this instance. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7MidiOut_7get_current_api, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiOut_get_current_api, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__70)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiOut, __pyx_n_s_get_current_api, __pyx_t_3) < 0) __PYX_ERR(0, 1052, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiOut); /* "_rtmidi.pyx":1066 * return self.thisptr.getCurrentApi() * * def send_message(self, message): # <<<<<<<<<<<<<< * """Send a MIDI message to the output port. * */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7MidiOut_9send_message, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiOut_send_message, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__72)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1066, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7_rtmidi_MidiOut, __pyx_n_s_send_message, __pyx_t_3) < 0) __PYX_ERR(0, 1066, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_7_rtmidi_MidiOut); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7MidiOut_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiOut___reduce_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(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__" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_7MidiOut_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MidiOut___setstate_cython, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__74)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":1 * def __pyx_unpickle_MidiBase(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7_rtmidi_15__pyx_unpickle_MidiBase, 0, __pyx_n_s_pyx_unpickle_MidiBase, NULL, __pyx_n_s_rtmidi, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_MidiBase, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_rtmidi.pyx":1 * # cython: embedsignature = True # <<<<<<<<<<<<<< * # cython: language_level = 3 * # cython: show_performance_hints = False */ __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); if (__pyx_m) { if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init _rtmidi", __pyx_clineno, __pyx_lineno, __pyx_filename); } #if !CYTHON_USE_MODULE_STATE Py_CLEAR(__pyx_m); #else Py_DECREF(__pyx_m); if (pystate_addmodule_run) { PyObject *tp, *value, *tb; PyErr_Fetch(&tp, &value, &tb); PyState_RemoveModule(&__pyx_moduledef); PyErr_Restore(tp, value, tb); } #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init _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 } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER #pragma warning( push ) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ #pragma warning( disable : 4127 ) #endif /* #### Code section: utility_code_def ### */ /* --- 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 /* 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; i= 0x030C00A6 PyObject *current_exception = tstate->current_exception; if (unlikely(!current_exception)) return 0; exc_type = (PyObject*) Py_TYPE(current_exception); if (exc_type == err) return 1; #else exc_type = tstate->curexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; #endif #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(exc_type); #endif if (unlikely(PyTuple_Check(err))) { result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); } else { result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(exc_type); #endif return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject *tmp_value; assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); if (value) { #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) #endif PyException_SetTraceback(value, tb); } tmp_value = tstate->current_exception; tstate->current_exception = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else 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); #endif } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject* exc_value; exc_value = tstate->current_exception; tstate->current_exception = 0; *value = exc_value; *type = NULL; *tb = NULL; if (exc_value) { *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); #if CYTHON_COMPILING_IN_CPYTHON *tb = ((PyBaseExceptionObject*) exc_value)->traceback; Py_XINCREF(*tb); #else *tb = PyException_GetTraceback(exc_value); #endif } #else *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 } #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 /* PyObjectGetAttrStrNoError */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 (void) PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else #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; #endif } /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { 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) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign PyObject* exc_type = __Pyx_PyErr_CurrentExceptionType(); if (unlikely(exc_type)) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) return -1; __Pyx_PyErr_Clear(); return 0; } return 0; } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } return __Pyx_IterFinish(); } /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL 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; } 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_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { return NULL; } #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } #endif 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 /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; #endif 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 /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); self = __Pyx_CyOrPyCFunction_GET_SELF(func); #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; #endif 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 /* PyObjectFastCall */ #if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { PyObject *argstuple; PyObject *result = 0; size_t i; argstuple = PyTuple_New((Py_ssize_t)nargs); if (unlikely(!argstuple)) return NULL; for (i = 0; i < nargs; i++) { Py_INCREF(args[i]); if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } result = __Pyx_PyObject_Call(func, argstuple, kwargs); bad: Py_DECREF(argstuple); return result; } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); #if CYTHON_COMPILING_IN_CPYTHON if (nargs == 0 && kwargs == NULL) { if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) return __Pyx_PyObject_CallMethO(func, NULL); } else if (nargs == 1 && kwargs == NULL) { if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) return __Pyx_PyObject_CallMethO(func, args[0]); } #endif #if PY_VERSION_HEX < 0x030800B1 #if CYTHON_FAST_PYCCALL if (PyCFunction_Check(func)) { if (kwargs) { return _PyCFunction_FastCallDict(func, args, nargs, kwargs); } else { return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); } } #if PY_VERSION_HEX >= 0x030700A1 if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); } #endif #endif #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } #endif #endif if (kwargs == NULL) { #if CYTHON_VECTORCALL #if PY_VERSION_HEX < 0x03090000 vectorcallfunc f = _PyVectorcall_Function(func); #else vectorcallfunc f = PyVectorcall_Function(func); #endif if (f) { return f(func, args, (size_t)nargs, NULL); } #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL if (__Pyx_CyFunction_CheckExact(func)) { __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); if (f) return f(func, args, (size_t)nargs, NULL); } #endif } if (nargs == 0) { return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); #else return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); #endif } /* TupleAndListFromArray */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { PyObject *v; Py_ssize_t i; for (i = 0; i < length; i++) { v = dest[i] = src[i]; Py_INCREF(v); } } static CYTHON_INLINE PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { Py_INCREF(__pyx_empty_tuple); return __pyx_empty_tuple; } res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); return res; } static CYTHON_INLINE PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { return PyList_New(0); } res = PyList_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); return res; } #endif /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API 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_VERSION_HEX < 0x030B0000) 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 || CYTHON_COMPILING_IN_LIMITED_API 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 } /* fastcall */ #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); for (i = 0; i < n; i++) { if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; } for (i = 0; i < n; i++) { int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; // error return kwvalues[i]; } } return NULL; // not found (no exception set) } #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 static CYTHON_UNUSED PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); PyObject *dict; dict = PyDict_New(); if (unlikely(!dict)) return NULL; for (i=0; i= 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 *const *kwvalues, 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; int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); while (1) { Py_XDECREF(key); key = NULL; Py_XDECREF(value); value = NULL; if (kwds_is_tuple) { Py_ssize_t size; #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(kwds); #else size = PyTuple_Size(kwds); if (size < 0) goto bad; #endif if (pos >= size) break; #if CYTHON_AVOID_BORROWED_REFS key = __Pyx_PySequence_ITEM(kwds, pos); if (!key) goto bad; #elif CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kwds, pos); #else key = PyTuple_GetItem(kwds, pos); if (!key) goto bad; #endif value = kwvalues[pos]; pos++; } else { if (!PyDict_Next(kwds, &pos, &key, &value)) break; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(key); #endif } name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(value); // transfer ownership of value to values Py_DECREF(key); #endif key = NULL; value = NULL; continue; } #if !CYTHON_AVOID_BORROWED_REFS Py_INCREF(key); #endif Py_INCREF(value); 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; #if CYTHON_AVOID_BORROWED_REFS value = NULL; // ownership transferred to values #endif 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 = ( #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; #if CYTHON_AVOID_BORROWED_REFS value = NULL; // ownership transferred to values #endif 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; } } Py_XDECREF(key); Py_XDECREF(value); 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: #if PY_MAJOR_VERSION < 3 PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: Py_XDECREF(key); Py_XDECREF(value); return -1; } /* 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); } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare CYTHON_UNUSED_VAR(cause); 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 PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); #elif CYTHON_FAST_THREAD_STATE 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); } #else 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); #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* 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); } } /* 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 && PY_VERSION_HEX < 0x030d0000 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; } #elif CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } #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); } /* PyObjectCallOneArg */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *args[2] = {NULL, arg}; return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kw, 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(kw, &pos, &key, 0)) goto invalid_keyword; return 1; #else if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { Py_ssize_t kwsize; #if CYTHON_ASSUME_SAFE_MACROS kwsize = PyTuple_GET_SIZE(kw); #else kwsize = PyTuple_Size(kw); if (kwsize < 0) return 0; #endif if (unlikely(kwsize == 0)) return 1; if (!kw_allowed) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, 0); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif goto invalid_keyword; } #if PY_VERSION_HEX < 0x03090000 for (pos = 0; pos < kwsize; pos++) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, pos); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } #endif return 1; } while (PyDict_Next(kw, &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: #if PY_MAJOR_VERSION < 3 PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* PyIntCompare */ static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_UNUSED_VAR(inplace); if (op1 == op2) { return 1; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); return (a == b); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); const digit* digits = __Pyx_PyLong_Digits(op1); if (intval == 0) { return (__Pyx_PyLong_IsZero(op1) == 1); } else if (intval < 0) { if (__Pyx_PyLong_IsNonNeg(op1)) return 0; intval = -intval; } else { if (__Pyx_PyLong_IsNeg(op1)) return 0; } 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)); return (unequal == 0); } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; #if CYTHON_COMPILING_IN_LIMITED_API double a = __pyx_PyFloat_AsDouble(op1); #else double a = PyFloat_AS_DOUBLE(op1); #endif return ((double)a == (double)b); } return __Pyx_PyObject_IsTrueAndDecref( 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, Py_UCS4 max_char) { #if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *result_uval; int result_ukind, kind_shift; Py_ssize_t i, char_pos; void *result_udata; CYTHON_MAYBE_UNUSED_VAR(max_char); #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; kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; 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); kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; result_udata = PyUnicode_AS_UNICODE(result_uval); #endif assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); 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((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) 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 << kind_shift), udata, (size_t) (ulength << kind_shift)); } else { #if PY_VERSION_HEX >= 0x030d0000 if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; #elif 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 CYTHON_UNUSED_VAR(max_char); CYTHON_UNUSED_VAR(result_ulength); CYTHON_UNUSED_VAR(value_count); return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #endif } /* PyIntCompare */ static CYTHON_INLINE int __Pyx_PyInt_BoolNeObjC(PyObject *op1, PyObject *op2, long intval, long inplace) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_UNUSED_VAR(inplace); if (op1 == op2) { return 0; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); return (a != b); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); const digit* digits = __Pyx_PyLong_Digits(op1); if (intval == 0) { return (__Pyx_PyLong_IsZero(op1) != 1); } else if (intval < 0) { if (__Pyx_PyLong_IsNonNeg(op1)) return 1; intval = -intval; } else { if (__Pyx_PyLong_IsNeg(op1)) return 1; } 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)); return (unequal != 0); } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; #if CYTHON_COMPILING_IN_LIMITED_API double a = __pyx_PyFloat_AsDouble(op1); #else double a = PyFloat_AS_DOUBLE(op1); #endif return ((double)a != (double)b); } return __Pyx_PyObject_IsTrueAndDecref( PyObject_RichCompare(op1, op2, Py_NE)); } /* GetAttr3 */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 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; } #endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 int res = PyObject_GetOptionalAttr(o, n, &r); return (res != 0) ? r : __Pyx_NewRef(d); #else #if CYTHON_USE_TYPE_SLOTS if (likely(PyString_Check(n))) { r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (unlikely(!r) && likely(!PyErr_Occurred())) { r = __Pyx_NewRef(d); } return r; } #endif r = PyObject_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #endif } /* RaiseUnexpectedTypeError */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, expected, obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_value == NULL || exc_info->exc_value == 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 && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); PyObject *exc_value = exc_info->exc_value; if (exc_value == NULL || exc_value == Py_None) { *value = NULL; *type = NULL; *tb = NULL; } else { *value = exc_value; Py_INCREF(*value); *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); *tb = PyException_GetTraceback(exc_value); } #elif 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; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; PyObject *tmp_value = exc_info->exc_value; exc_info->exc_value = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else 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 } #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 = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; #if PY_VERSION_HEX >= 0x030C00A6 local_value = tstate->current_exception; tstate->current_exception = 0; if (likely(local_value)) { local_type = (PyObject*) Py_TYPE(local_value); Py_INCREF(local_type); local_tb = PyException_GetTraceback(local_value); } #else 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; #endif #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 if (unlikely(tstate->current_exception)) #elif 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; #if PY_VERSION_HEX >= 0x030B00a4 tmp_value = exc_info->exc_value; exc_info->exc_value = local_value; tmp_type = NULL; tmp_tb = NULL; Py_XDECREF(local_type); Py_XDECREF(local_tb); #else 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; #endif } #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; } /* 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 && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; tmp_value = exc_info->exc_value; exc_info->exc_value = *value; if (tmp_value == NULL || tmp_value == Py_None) { Py_XDECREF(tmp_value); tmp_value = NULL; tmp_type = NULL; tmp_tb = NULL; } else { tmp_type = (PyObject*) Py_TYPE(tmp_value); Py_INCREF(tmp_type); #if CYTHON_COMPILING_IN_CPYTHON tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; Py_XINCREF(tmp_tb); #else tmp_tb = PyException_GetTraceback(tmp_value); #endif } #elif 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 /* 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); } /* HasAttr */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 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 (!r) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, 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(); else state = (PyGILState_STATE)0; #endif CYTHON_UNUSED_VAR(clineno); CYTHON_UNUSED_VAR(lineno); CYTHON_UNUSED_VAR(filename); CYTHON_MAYBE_UNUSED_VAR(nogil); __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 } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *module = 0; PyObject *empty_dict = 0; PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (unlikely(!py_import)) goto bad; if (!from_list) { empty_list = PyList_New(0); if (unlikely(!empty_list)) goto bad; from_list = empty_list; } #endif empty_dict = PyDict_New(); if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!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 (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, level); #endif } } bad: Py_XDECREF(empty_dict); Py_XDECREF(empty_list); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif 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)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__9); if (unlikely(!module_dot)) { goto modbad; } full_name = PyUnicode_Concat(module_dot, name); if (unlikely(!full_name)) { goto modbad; } #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) goto modbad; value = PyObject_GetItem(modules, full_name); } #else value = PyImport_GetModule(full_name); #endif modbad: Py_XDECREF(full_name); Py_XDECREF(module_dot); Py_XDECREF(module_name); } if (unlikely(!value)) { 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; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!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 { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; if (mm && mm->mp_subscript) { PyObject *r, *key = PyInt_FromSsize_t(i); if (unlikely(!key)) return NULL; r = mm->mp_subscript(o, key); Py_DECREF(key); return r; } if (likely(sm && sm->sq_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return sm->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)); } /* FixUpExtensionType */ #if CYTHON_USE_TYPE_SPECS static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { #if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED_VAR(spec); CYTHON_UNUSED_VAR(type); #else const PyType_Slot *slot = spec->slots; while (slot && slot->slot && slot->slot != Py_tp_members) slot++; if (slot && slot->slot == Py_tp_members) { int changed = 0; #if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) const #endif PyMemberDef *memb = (PyMemberDef*) slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { #if PY_VERSION_HEX < 0x030900b1 if (strcmp(memb->name, "__weaklistoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_weaklistoffset = memb->offset; changed = 1; } else if (strcmp(memb->name, "__dictoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_dictoffset = memb->offset; changed = 1; } #if CYTHON_METH_FASTCALL else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); #if PY_VERSION_HEX >= 0x030800b4 type->tp_vectorcall_offset = memb->offset; #else type->tp_print = (printfunc) memb->offset; #endif changed = 1; } #endif #else if ((0)); #endif #if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON else if (strcmp(memb->name, "__module__") == 0) { PyObject *descr; assert(memb->type == T_OBJECT); assert(memb->flags == 0 || memb->flags == READONLY); descr = PyDescr_NewMember(type, memb); if (unlikely(!descr)) return -1; if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { Py_DECREF(descr); return -1; } Py_DECREF(descr); changed = 1; } #endif } memb++; } if (changed) PyType_Modified(type); } #endif return 0; } #endif /* PyObjectCallNoArg */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { PyObject *arg[2] = {NULL, NULL}; return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP __Pyx_TypeName type_name; PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) #elif PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (likely(descr != NULL)) { *method = descr; return 0; } type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, name); #else "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", type_name, PyString_AS_STRING(name)); #endif __Pyx_DECREF_TypeName(type_name); return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* ValidateBasesTuple */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { Py_ssize_t i, n; #if CYTHON_ASSUME_SAFE_MACROS n = PyTuple_GET_SIZE(bases); #else n = PyTuple_Size(bases); if (n < 0) return -1; #endif for (i = 1; i < n; i++) { #if CYTHON_AVOID_BORROWED_REFS PyObject *b0 = PySequence_GetItem(bases, i); if (!b0) return -1; #elif CYTHON_ASSUME_SAFE_MACROS PyObject *b0 = PyTuple_GET_ITEM(bases, i); #else PyObject *b0 = PyTuple_GetItem(bases, i); if (!b0) return -1; #endif PyTypeObject *b; #if PY_MAJOR_VERSION < 3 if (PyClass_Check(b0)) { PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } #endif b = (PyTypeObject*) b0; if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) { __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); PyErr_Format(PyExc_TypeError, "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); __Pyx_DECREF_TypeName(b_name); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } #if !CYTHON_USE_TYPE_SLOTS if (dictoffset == 0) { PyErr_Format(PyExc_TypeError, "extension type '%s.200s': " "unable to validate whether bases have a __dict__ " "when CYTHON_USE_TYPE_SLOTS is off " "(likely because you are building in the limited API). " "Therefore, all extension types with multiple bases " "must add 'cdef dict __dict__' in this compilation mode", type_name); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } #else if (dictoffset == 0 && b->tp_dictoffset) { __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); PyErr_Format(PyExc_TypeError, "extension type '%.200s' has no __dict__ slot, " "but base type '" __Pyx_FMT_TYPENAME "' has: " "either add 'cdef dict __dict__' to the extension type " "or add '__slots__ = [...]' to the base type", type_name, b_name); __Pyx_DECREF_TypeName(b_name); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif } return 0; } #endif /* PyType_Ready */ static int __Pyx_PyType_Ready(PyTypeObject *t) { #if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) (void)__Pyx_PyObject_CallMethod0; #if CYTHON_USE_TYPE_SPECS (void)__Pyx_validate_bases_tuple; #endif return PyType_Ready(t); #else int r; PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) return -1; #if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) { int gc_was_enabled; #if PY_VERSION_HEX >= 0x030A00b1 gc_was_enabled = PyGC_Disable(); (void)__Pyx_PyObject_CallMethod0; #else PyObject *ret, *py_status; PyObject *gc = NULL; #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) gc = PyImport_GetModule(__pyx_kp_u_gc); #endif if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); if (unlikely(!gc)) return -1; py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); if (unlikely(!py_status)) { Py_DECREF(gc); return -1; } gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); Py_DECREF(py_status); if (gc_was_enabled > 0) { ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); if (unlikely(!ret)) { Py_DECREF(gc); return -1; } Py_DECREF(ret); } else if (unlikely(gc_was_enabled == -1)) { Py_DECREF(gc); return -1; } #endif t->tp_flags |= Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A0000 t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif #else (void)__Pyx_PyObject_CallMethod0; #endif r = PyType_Ready(t); #if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A00b1 if (gc_was_enabled) PyGC_Enable(); #else if (gc_was_enabled) { PyObject *tp, *v, *tb; PyErr_Fetch(&tp, &v, &tb); ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); if (likely(ret || r == -1)) { Py_XDECREF(ret); PyErr_Restore(tp, v, tb); } else { Py_XDECREF(tp); Py_XDECREF(v); Py_XDECREF(tb); r = -1; } } Py_DECREF(gc); #endif } #endif return r; #endif } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, attr_name); #else "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", type_name, PyString_AS_STRING(attr_name)); #endif __Pyx_DECREF_TypeName(type_name); 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(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); if (unlikely(!ob)) goto bad; #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* GetVTable */ static void* __Pyx_GetVtable(PyTypeObject *type) { void* ptr; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); #else PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); #endif if (!ob) goto bad; ptr = PyCapsule_GetPointer(ob, 0); if (!ptr && !PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); Py_DECREF(ob); return ptr; bad: Py_XDECREF(ob); return NULL; } /* MergeVTables */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type) { int i; void** base_vtables; __Pyx_TypeName tp_base_name; __Pyx_TypeName base_name; void* unknown = (void*)-1; PyObject* bases = type->tp_bases; int base_depth = 0; { PyTypeObject* base = type->tp_base; while (base) { base_depth += 1; base = base->tp_base; } } base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); base_vtables[0] = unknown; for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); if (base_vtable != NULL) { int j; PyTypeObject* base = type->tp_base; for (j = 0; j < base_depth; j++) { if (base_vtables[j] == unknown) { base_vtables[j] = __Pyx_GetVtable(base); base_vtables[j + 1] = unknown; } if (base_vtables[j] == base_vtable) { break; } else if (base_vtables[j] == NULL) { goto bad; } base = base->tp_base; } } } PyErr_Clear(); free(base_vtables); return 0; bad: tp_base_name = __Pyx_PyType_GetName(type->tp_base); base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); PyErr_Format(PyExc_TypeError, "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); __Pyx_DECREF_TypeName(tp_base_name); __Pyx_DECREF_TypeName(base_name); free(base_vtables); return -1; } #endif /* SetupReduce */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStrNoError(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_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #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_GetAttrStrNoError(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()) { __Pyx_TypeName type_obj_name = __Pyx_PyType_GetName((PyTypeObject*)type_obj); PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); __Pyx_DECREF_TypeName(type_obj_name); } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } #endif /* ImportDottedModule */ #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; if (unlikely(PyErr_Occurred())) { PyErr_Clear(); } if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { partial_name = name; } else { slice = PySequence_GetSlice(parts_tuple, 0, count); if (unlikely(!slice)) goto bad; sep = PyUnicode_FromStringAndSize(".", 1); if (unlikely(!sep)) goto bad; partial_name = PyUnicode_Join(sep, slice); } PyErr_Format( #if PY_MAJOR_VERSION < 3 PyExc_ImportError, "No module named '%s'", PyString_AS_STRING(partial_name)); #else #if PY_VERSION_HEX >= 0x030600B1 PyExc_ModuleNotFoundError, #else PyExc_ImportError, #endif "No module named '%U'", partial_name); #endif bad: Py_XDECREF(sep); Py_XDECREF(slice); Py_XDECREF(partial_name); return NULL; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { PyObject *imported_module; #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) return NULL; imported_module = __Pyx_PyDict_GetItemStr(modules, name); Py_XINCREF(imported_module); #else imported_module = PyImport_GetModule(name); #endif return imported_module; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { Py_ssize_t i, nparts; nparts = PyTuple_GET_SIZE(parts_tuple); for (i=1; i < nparts && module; i++) { PyObject *part, *submodule; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS part = PyTuple_GET_ITEM(parts_tuple, i); #else part = PySequence_ITEM(parts_tuple, i); #endif submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(part); #endif Py_DECREF(module); module = submodule; } if (unlikely(!module)) { return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); } return module; } #endif static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if PY_MAJOR_VERSION < 3 PyObject *module, *from_list, *star = __pyx_n_s__10; CYTHON_UNUSED_VAR(parts_tuple); from_list = PyList_New(1); if (unlikely(!from_list)) return NULL; Py_INCREF(star); PyList_SET_ITEM(from_list, 0, star); module = __Pyx_Import(name, from_list, 0); Py_DECREF(from_list); return module; #else PyObject *imported_module; PyObject *module = __Pyx_Import(name, NULL, 0); if (!parts_tuple || unlikely(!module)) return module; imported_module = __Pyx__ImportDottedModule_Lookup(name); if (likely(imported_module)) { Py_DECREF(module); return imported_module; } PyErr_Clear(); return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); #endif } static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 PyObject *module = __Pyx__ImportDottedModule_Lookup(name); if (likely(module)) { PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); if (likely(spec)) { PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { Py_DECREF(spec); spec = NULL; } Py_XDECREF(unsafe); } if (likely(!spec)) { PyErr_Clear(); return module; } Py_DECREF(spec); Py_DECREF(module); } else if (PyErr_Occurred()) { PyErr_Clear(); } #endif return __Pyx__ImportDottedModule(name, parts_tuple); } /* FetchSharedCythonModule */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); } /* FetchCommonType */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t basicsize, Py_ssize_t expected_basicsize) { if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (basicsize != expected_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } #if !CYTHON_USE_TYPE_SPECS static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* abi_module; const char* object_name; PyTypeObject *cached_type = NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; object_name = strrchr(type->tp_name, '.'); object_name = object_name ? object_name+1 : type->tp_name; cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); if (cached_type) { if (__Pyx_VerifyCachedType( (PyObject *)cached_type, object_name, cached_type->tp_basicsize, type->tp_basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) goto bad; Py_INCREF(type); cached_type = type; done: Py_DECREF(abi_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #else static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module, *cached_type = NULL; const char* object_name = strrchr(spec->name, '.'); object_name = object_name ? object_name+1 : spec->name; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; cached_type = PyObject_GetAttrString(abi_module, object_name); if (cached_type) { Py_ssize_t basicsize; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); if (unlikely(!py_basicsize)) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; #else basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif if (__Pyx_VerifyCachedType( cached_type, object_name, basicsize, spec->basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); CYTHON_UNUSED_VAR(module); cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; done: Py_DECREF(abi_module); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #endif /* PyVectorcallFastCallDict */ #if CYTHON_METH_FASTCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; Py_ssize_t i, pos; size_t j; PyObject *key, *value; unsigned long keys_are_strings; Py_ssize_t nkw = PyDict_GET_SIZE(kw); newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; while (PyDict_Next(kw, &pos, &key, &value)) { keys_are_strings &= Py_TYPE(key)->tp_flags; Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(kwnames, i, key); kwvalues[i] = value; i++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } res = vc(func, newargs, nargs, kwnames); cleanup: Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { return vc(func, args, nargs, NULL); } return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif /* CythonFunctionShared */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { if (__Pyx_CyFunction_Check(func)) { return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } return 0; } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API __Pyx_Py_XDECREF_SET( __Pyx_CyFunction_GetClassObj(f), ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else __Pyx_Py_XDECREF_SET( ((PyCMethodObject *) (f))->mm_class, (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif } static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { CYTHON_UNUSED_VAR(closure); if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); if (unlikely(!op->func_doc)) return NULL; #else if (((PyCFunctionObject*)op)->m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #else op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } #endif } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_doc, value); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); #elif PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #else op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->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, void *context) { CYTHON_UNUSED_VAR(context); #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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_name, value); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_qualname, value); return 0; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(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, void *context) { CYTHON_UNUSED_VAR(context); 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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_dict, value); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; CYTHON_UNUSED_VAR(context); 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 = __Pyx_PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = __Pyx_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, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_tuple; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__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, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_kwdict; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__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, void *context) { CYTHON_UNUSED_VAR(context); if (!value || value == Py_None) { value = NULL; } else if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); __Pyx_Py_XDECREF_SET(op->func_annotations, value); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->func_annotations; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { int is_coroutine; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { return __Pyx_NewRef(op->func_is_coroutine); } is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; #if PY_VERSION_HEX >= 0x03050000 if (is_coroutine) { PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(marker); Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) goto ignore; op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); if (likely(op->func_is_coroutine)) { return __Pyx_NewRef(op->func_is_coroutine); } ignore: PyErr_Clear(); } #endif op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); return __Pyx_NewRef(op->func_is_coroutine); } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_GetAttrString(op->func, "__module__"); } static int __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_SetAttrString(op->func, "__module__", value); } #endif 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 *) "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}, {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if CYTHON_USE_TYPE_SPECS {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #if CYTHON_METH_FASTCALL #if CYTHON_BACKPORT_VECTORCALL {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #endif #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else return PyString_FromString(((PyCFunctionObject*)m)->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 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->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 !CYTHON_COMPILING_IN_LIMITED_API PyCFunctionObject *cf = (PyCFunctionObject*) op; #endif if (unlikely(op == NULL)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); if (unlikely(!op->func)) return NULL; #endif op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; #if !CYTHON_COMPILING_IN_LIMITED_API cf->m_ml = ml; cf->m_self = (PyObject *) op; #endif Py_XINCREF(closure); op->func_closure = closure; #if !CYTHON_COMPILING_IN_LIMITED_API Py_XINCREF(module); cf->m_module = module; #endif op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif 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; op->func_is_coroutine = NULL; #if CYTHON_METH_FASTCALL switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { case METH_NOARGS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; break; case METH_O: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; break; case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; break; case METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; break; case METH_VARARGS | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = NULL; break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); Py_DECREF(op); return NULL; } #endif return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif 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); #if !CYTHON_COMPILING_IN_LIMITED_API #if PY_VERSION_HEX < 0x030900B1 Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); Py_CLEAR(m->func_is_coroutine); 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); __Pyx_PyHeapTypeObject_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); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif 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); #if !CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); #endif Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_is_coroutine); 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_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) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *f = ((__pyx_CyFunctionObject*)func)->func; PyObject *py_name = NULL; PyCFunction meth; int flags; meth = PyCFunction_GetFunction(f); if (unlikely(!meth)) return NULL; flags = PyCFunction_GetFlags(f); if (unlikely(flags < 0)) return NULL; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (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)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_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; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", py_name); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); #endif return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *self, *result; #if CYTHON_COMPILING_IN_LIMITED_API self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); if (unlikely(!self) && PyErr_Occurred()) return NULL; #else self = ((PyCFunctionObject*)func)->m_self; #endif result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; #if CYTHON_METH_FASTCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_MACROS argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(!argc) < 0) return NULL; #endif 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); #if PY_MAJOR_VERSION > 2 PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); #else PyErr_SetString(PyExc_TypeError, "unbound method needs an argument"); #endif 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; } #if CYTHON_METH_FASTCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 0)) { PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 1)) { PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } #endif #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; #else static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, #if !CYTHON_METH_FASTCALL 0, #elif CYTHON_BACKPORT_VECTORCALL (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), #else offsetof(PyCFunctionObject, vectorcall), #endif 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, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 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_PyMethod_New, 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 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if __PYX_NEED_TP_PRINT_SLOT 0, #endif #if PY_VERSION_HEX >= 0x030C0000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, #endif }; #endif static int __pyx_CyFunction_init(PyObject *module) { #if CYTHON_USE_TYPE_SPECS __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else CYTHON_UNUSED_VAR(module); __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif 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; } /* Py3UpdateBases */ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases) { Py_ssize_t i, j, size_bases; PyObject *base, *meth, *new_base, *result, *new_bases = NULL; size_bases = PyTuple_GET_SIZE(bases); for (i = 0; i < size_bases; i++) { base = PyTuple_GET_ITEM(bases, i); if (PyType_Check(base)) { if (new_bases) { if (PyList_Append(new_bases, base) < 0) { goto error; } } continue; } meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_n_s_mro_entries); if (!meth && PyErr_Occurred()) { goto error; } if (!meth) { if (new_bases) { if (PyList_Append(new_bases, base) < 0) { goto error; } } continue; } new_base = __Pyx_PyObject_CallOneArg(meth, bases); Py_DECREF(meth); if (!new_base) { goto error; } if (!PyTuple_Check(new_base)) { PyErr_SetString(PyExc_TypeError, "__mro_entries__ must return a tuple"); Py_DECREF(new_base); goto error; } if (!new_bases) { if (!(new_bases = PyList_New(i))) { goto error; } for (j = 0; j < i; j++) { base = PyTuple_GET_ITEM(bases, j); PyList_SET_ITEM(new_bases, j, base); Py_INCREF(base); } } j = PyList_GET_SIZE(new_bases); if (PyList_SetSlice(new_bases, j, j, new_base) < 0) { goto error; } Py_DECREF(new_base); } if (!new_bases) { Py_INCREF(bases); return bases; } result = PyList_AsTuple(new_bases); Py_DECREF(new_bases); return result; error: Py_XDECREF(new_bases); return NULL; } /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { Py_ssize_t i, nbases; #if CYTHON_ASSUME_SAFE_MACROS nbases = PyTuple_GET_SIZE(bases); #else nbases = PyTuple_Size(bases); if (nbases < 0) return NULL; #endif for (i=0; i < nbases; i++) { PyTypeObject *tmptype; #if CYTHON_ASSUME_SAFE_MACROS PyObject *tmp = PyTuple_GET_ITEM(bases, i); #else PyObject *tmp = PyTuple_GetItem(bases, i); if (!tmp) return NULL; #endif 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; } /* PyObjectCall2Args */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args[3] = {NULL, arg1, arg2}; return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* PyObjectLookupSpecial */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else if (with_error) { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #endif /* 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_GetAttrStrNoError(metaclass, __pyx_n_s_prepare); if (prep) { PyObject *pargs[3] = {NULL, name, bases}; ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); Py_DECREF(prep); } else { if (unlikely(PyErr_Occurred())) return NULL; 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 PY_VERSION_HEX >= 0x03030000 if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; #else CYTHON_MAYBE_UNUSED_VAR(qualname); #endif if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; return ns; bad: Py_DECREF(ns); return NULL; } #if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS static int __Pyx_SetNamesPEP487(PyObject *type_obj) { PyTypeObject *type = (PyTypeObject*) type_obj; PyObject *names_to_set, *key, *value, *set_name, *tmp; Py_ssize_t i = 0; #if CYTHON_USE_TYPE_SLOTS names_to_set = PyDict_Copy(type->tp_dict); #else { PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict); names_to_set = NULL; if (likely(d)) { PyObject *names_to_set = PyDict_New(); int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1; Py_DECREF(d); if (unlikely(ret < 0)) Py_CLEAR(names_to_set); } } #endif if (unlikely(names_to_set == NULL)) goto bad; while (PyDict_Next(names_to_set, &i, &key, &value)) { set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name); if (unlikely(set_name != NULL)) { tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key); Py_DECREF(set_name); if (unlikely(tmp == NULL)) { __Pyx_TypeName value_type_name = __Pyx_PyType_GetName(Py_TYPE(value)); __Pyx_TypeName type_name = __Pyx_PyType_GetName(type); PyErr_Format(PyExc_RuntimeError, #if PY_MAJOR_VERSION >= 3 "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'", value_type_name, key, type_name); #else "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'", value_type_name, PyString_Check(key) ? PyString_AS_STRING(key) : "?", type_name); #endif goto bad; } else { Py_DECREF(tmp); } } else if (unlikely(PyErr_Occurred())) { goto bad; } } Py_DECREF(names_to_set); return 0; bad: Py_XDECREF(names_to_set); return -1; } static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) { #if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyTypeObject *type = (PyTypeObject*) type_obj; PyObject *mro = type->tp_mro; Py_ssize_t i, nbases; if (unlikely(!mro)) goto done; (void) &__Pyx_GetBuiltinName; Py_INCREF(mro); nbases = PyTuple_GET_SIZE(mro); assert(PyTuple_GET_ITEM(mro, 0) == type_obj); for (i = 1; i < nbases-1; i++) { PyObject *base, *dict, *meth; base = PyTuple_GET_ITEM(mro, i); dict = ((PyTypeObject *)base)->tp_dict; meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass); if (unlikely(meth)) { descrgetfunc f = Py_TYPE(meth)->tp_descr_get; PyObject *res; Py_INCREF(meth); if (likely(f)) { res = f(meth, NULL, type_obj); Py_DECREF(meth); if (unlikely(!res)) goto bad; meth = res; } res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw); Py_DECREF(meth); if (unlikely(!res)) goto bad; Py_DECREF(res); goto done; } else if (unlikely(PyErr_Occurred())) { goto bad; } } done: Py_XDECREF(mro); return type_obj; bad: Py_XDECREF(mro); Py_DECREF(type_obj); return NULL; #else PyObject *super_type, *super, *func, *res; #if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) super_type = __Pyx_GetBuiltinName(__pyx_n_s_super); #else super_type = (PyObject*) &PySuper_Type; (void) &__Pyx_GetBuiltinName; #endif super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL; #if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) Py_XDECREF(super_type); #endif if (unlikely(!super)) { Py_CLEAR(type_obj); goto done; } func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass); Py_DECREF(super); if (likely(!func)) { if (unlikely(PyErr_Occurred())) Py_CLEAR(type_obj); goto done; } res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw); Py_DECREF(func); if (unlikely(!res)) Py_CLEAR(type_obj); Py_XDECREF(res); done: return type_obj; #endif } #endif static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { PyObject *result; PyObject *owned_metaclass = NULL; PyObject *margs[4] = {NULL, name, bases, dict}; 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; } result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, #if PY_VERSION_HEX < 0x030600A4 (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw #else mkw #endif ); Py_XDECREF(owned_metaclass); #if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS if (likely(result) && likely(PyType_Check(result))) { if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) { Py_CLEAR(result); } else { result = __Pyx_InitSubclassPEP487(result, mkw); } } #else (void) &__Pyx_GetBuiltinName; #endif 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 __Pyx_CyFunction_SetClassObj(m, classobj); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF((PyObject*)m); #endif } return 0; } /* GetNameInClass */ static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { PyObject *result; PyObject *dict; assert(PyType_Check(nmspace)); #if CYTHON_USE_TYPE_SLOTS dict = ((PyTypeObject*)nmspace)->tp_dict; Py_XINCREF(dict); #else dict = PyObject_GetAttr(nmspace, __pyx_n_s_dict); #endif if (likely(dict)) { result = PyObject_GetItem(dict, name); Py_DECREF(dict); if (result) { return result; } } PyErr_Clear(); __Pyx_GetModuleGlobalNameUncached(result, name); return result; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif CYTHON_MAYBE_UNUSED_VAR(tstate); 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_GetAttrStrNoError(__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; (void) 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 */ #if !CYTHON_COMPILING_IN_LIMITED_API 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); } #endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result; result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } PyErr_Clear(); #if __PYX_LIMITED_VERSION_HEX < 0x030780000 { PyObject *compiled = NULL, *result = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; compiled = Py_CompileString( "out = type(code)(\n" " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" " code.co_lnotab)\n", "", Py_file_input); if (!compiled) return NULL; result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); Py_DECREF(compiled); if (!result) PyErr_Print(); Py_DECREF(result); result = PyDict_GetItemString(scratch_dict, "out"); if (result) Py_INCREF(result); return result; } #else return NULL; #endif } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { (void) __pyx_cfilenm; (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = Py_CompileString("_getframe()", filename, Py_eval_input); if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; py_funcname = PyUnicode_FromString(funcname); if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; { PyObject *old_code_object = code_object; code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); Py_DECREF(old_code_object); } if (unlikely(!code_object)) goto bad; getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: PyErr_Restore(exc_type, exc_value, exc_traceback); Py_XDECREF(code_object); Py_XDECREF(py_py_line); Py_XDECREF(py_funcname); Py_XDECREF(dict); Py_XDECREF(replace); if (success) { PyTraceBack_Here( (struct _frame*)frame); } Py_XDECREF(frame); } #else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 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); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif 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; PyObject *ptype, *pvalue, *ptraceback; 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) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __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); } #endif /* 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_enum__RtMidi_3a__3a_Api(enum RtMidi::Api value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const enum RtMidi::Api neg_one = (enum RtMidi::Api) -1, const_zero = (enum RtMidi::Api) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(enum RtMidi::Api), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(enum RtMidi::Api)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__RtMidiError_3a__3a_Type(enum RtMidiError::Type value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const enum RtMidiError::Type neg_one = (enum RtMidiError::Type) -1, const_zero = (enum RtMidiError::Type) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(enum RtMidiError::Type), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(enum RtMidiError::Type)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (unsigned int) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (unsigned int) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (unsigned int) -1; } else { stepval = __Pyx_NewRef(v); } val = (unsigned int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((unsigned int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((unsigned int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const enum RtMidi::Api neg_one = (enum RtMidi::Api) -1, const_zero = (enum RtMidi::Api) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(enum RtMidi::Api, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available, cannot convert large enums"); 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) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (long) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (long) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (long) -1; } else { stepval = __Pyx_NewRef(v); } val = (long) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (size_t) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (size_t) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (size_t) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (size_t) -1; } else { stepval = __Pyx_NewRef(v); } val = (size_t) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((size_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((size_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned char neg_one = (unsigned char) -1, const_zero = (unsigned char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned char), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned char)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned char neg_one = (unsigned char) -1, const_zero = (unsigned char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (unsigned char) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (unsigned char) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned char) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (unsigned char) -1; } else { stepval = __Pyx_NewRef(v); } val = (unsigned char) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(unsigned char) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((unsigned char) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(unsigned char) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((unsigned char) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((unsigned char) 1) << (sizeof(unsigned char) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* FormatTypeName */ #if CYTHON_COMPILING_IN_LIMITED_API static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp) { PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_n_s_name_2); if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { PyErr_Clear(); Py_XDECREF(name); name = __Pyx_NewRef(__pyx_n_s__77); } return name; } #endif /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (int) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (int) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (int) -1; } else { stepval = __Pyx_NewRef(v); } val = (int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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 = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); 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); } static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (cls == a || cls == b) return 1; mro = cls->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { PyObject *base = PyTuple_GET_ITEM(mro, i); if (base == (PyObject *)a || base == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, 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) { if (exc_type1) { return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); } else { return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } } #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; i= 0x030B00A4 return Py_Version & ~0xFFUL; #else const char* rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); ++i; } version += factor * digit; if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; } return version; #endif } static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { const unsigned long MAJOR_MINOR = 0xFFFF0000UL; if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) return 0; if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) return 1; { char message[200]; PyOS_snprintf(message, sizeof(message), "compile time Python version %d.%d " "of module '%.100s' " "%s " "runtime version %d.%d", (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), __Pyx_MODULE_NAME, (allow_newer) ? "was newer than" : "does not match", (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) ); return PyErr_WarnEx(NULL, message, 1); } } /* InitStrings */ #if PY_MAJOR_VERSION >= 3 static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { if (t.is_unicode | t.is_str) { if (t.intern) { *str = PyUnicode_InternFromString(t.s); } else if (t.encoding) { *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); } else { *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); } } else { *str = PyBytes_FromStringAndSize(t.s, t.n - 1); } if (!*str) return -1; if (PyObject_Hash(*str) == -1) return -1; return 0; } #endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION >= 3 __Pyx_InitString(*t, t->p); #else 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); } if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; #endif ++t; } return 0; } #include static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { size_t len = strlen(s); if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "byte string is too long"); return -1; } return (Py_ssize_t) len; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return __Pyx_PyUnicode_FromStringAndSize(c_str, len); } static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return PyByteArray_FromStringAndSize(c_str, len); } 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 && !CYTHON_COMPILING_IN_LIMITED_API) || (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) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " "The ability to return an instance of a strict subclass of int is deprecated, " "and may be removed in a future version of Python.", result_type_name)) { __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", type_name, type_name, result_type_name); __Pyx_DECREF_TypeName(result_type_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 if (likely(__Pyx_PyLong_IsCompact(b))) { return __Pyx_PyLong_CompactValue(b); } else { const digit* digits = __Pyx_PyLong_Digits(b); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); 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 (Py_hash_t) __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); } /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/src/_rtmidi.pyx0000644000000000000000000011433514526744666014357 0ustar00# cython: embedsignature = True # cython: language_level = 3 # cython: show_performance_hints = False # distutils: language = c++ # # 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.8+). 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) ``API_RWEB_MIDI`` W3C Web MIDI API 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', 'API_WEB_MIDI', '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' ) cdef extern from "Python.h": void Py_Initialize() Py_Initialize() # 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" WEB_MIDI "RtMidi::WEB_MIDI_API" 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) except * with gil ctypedef void (*RtMidiErrorCallback)(ErrorType errorType, const string errorText, void *userData) except * with gil 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) except * 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 str object into bytes.""" if isinstance(name, str): name = bytes(name, 'utf-8') # Python 3 if not isinstance(name, bytes): raise TypeError("name must be a bytes instance.") 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_WEB_MIDI = WEB_MIDI 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 from 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 ``bytes``. """ 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 ``bytes``. """ 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 a (unicode) str or UTF-8 encoded bytes. 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 a (unicode) str or UTF-8 encoded bytes. 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 a (unicode) str or UTF-8 encoded bytes. 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 a (unicode) str or UTF-8 encoded bytes. 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 a (unicode) str or UTF-8 encoded bytes. 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 a (unicode) str or UTF-8 encoded bytes. 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. .. note:: with some backend APIs (notably ```WINDOWS_MM``) this function blocks until the whole message is sent. 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 try: msg_v.reserve(len(message)) except TypeError: pass for c in message: msg_v.push_back(c) if msg_v.size() == 0: raise ValueError("'message' must not be empty.") elif msg_v.size() > 3 and msg_v.at(0) != 0xF0: raise ValueError("'message' longer than 3 bytes but does not " "start with 0xF0.") self.thisptr.sendMessage(&msg_v) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/src/meson.build0000644000000000000000000000153114526744666014321 0ustar00fs = import('fs') rtmidi_sources = files([ 'rtmidi/RtMidi.cpp', ]) rtmidi_inc = include_directories('.', 'rtmidi') rtmidi_mod_pyx = '_rtmidi.pyx' rtmidi_mod_cpp = '_rtmidi.cpp' cython = find_program('cython3', 'cython', required: false) if fs.exists(rtmidi_mod_cpp) rtmidi_cython = files(rtmidi_mod_cpp) elif cython.found() rtmidi_cython = custom_target( 'rtmidi_cython', output: rtmidi_mod_cpp, input: rtmidi_mod_pyx, depend_files: [rtmidi_sources], command: [cython, '-3', '--cplus', '-o', '@OUTPUT@', '@INPUT@'], ) else error('The \'cython\' program was not found but is required.\n' + 'Please install Cython from: https://pypi.org/project/Cython/.') endif cythonize_dist_script = files('meson_dist_cython.py') meson.add_dist_script(python, cythonize_dist_script, rtmidi_mod_cpp) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/src/meson_dist_cython.py0000755000000000000000000000235514526744666016271 0ustar00#!/usr/bin/env python import argparse import shutil import sys from os import chdir, environ, getcwd from os.path import join from subprocess import run build_root = environ.get("MESON_BUILD_ROOT") dist_root = environ.get("MESON_DIST_ROOT") source_root = environ.get("MESON_SOURCE_ROOT") verbose = environ.get("MESON_INSTALL_QUIET") is None ap = argparse.ArgumentParser() ap.add_argument("-v", "--verbose", action="store_true", default=verbose, help="Be more verbose.") ap.add_argument("mod_source", nargs="*", help="Cython module C++ source target(s) (*.cpp).") args = ap.parse_args() if args.verbose: print("cwd:", getcwd()) print("build root:", build_root) print("dist root:", dist_root) print("source root:", source_root) print("sys.argv:", sys.argv) for mod in args.mod_source: target = join("src", mod) dst = join(dist_root, "src", mod) if args.verbose: print("Updating Cython module C source '{}'...".format(target)) cmd = ["ninja"] if args.verbose: cmd += ["-v"] cmd += [target] chdir(build_root) proc = run(cmd) if proc.returncode != 0: sys.exit("'ninja' returned non-zero ({}) for target '{}'.".format(proc.returncode, target)) shutil.copy(target, dst) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/CMakeLists.txt0000644000000000000000000002311614441703147016173 0ustar00# 2018 (c) Juan G. Victores, Bartek Łukawski, Stephen Sinclair # CopyPolicy: RtMidi license. # Set minimum CMake required version for this project. cmake_minimum_required(VERSION 3.10 FATAL_ERROR) # Define a C++ project. project(RtMidi LANGUAGES CXX C) # standards version set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # Check for Jack (any OS) find_library(JACK_LIB jack) find_package(PkgConfig) pkg_check_modules(jack jack) if(JACK_LIB OR jack_FOUND) set(HAVE_JACK TRUE) endif() # Necessary for Windows if(WIN32) set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif() # Standard CMake options option(BUILD_SHARED_LIBS "Build as shared library" ON) if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE) set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug;Release;RelWithDebInfo;MinSizeRel") endif() if(WINDOWS) set(CMAKE_DEBUG_POSTFIX d CACHE STRING "Postfix for debug version of library") endif() # Build Options set(RTMIDI_TARGETNAME_UNINSTALL "uninstall" CACHE STRING "Name of 'uninstall' build target") # API Options option(RTMIDI_API_JACK "Compile with JACK support." ${HAVE_JACK}) if(UNIX AND NOT APPLE) option(RTMIDI_API_ALSA "Compile with ALSA support." ON) endif() option(RTMIDI_API_WINMM "Compile with WINMM support." ${WIN32}) option(RTMIDI_API_CORE "Compile with CoreMIDI support." ${APPLE}) # Add -Wall if possible if (CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") endif (CMAKE_COMPILER_IS_GNUCXX) # Add debug flags if (CMAKE_BUILD_TYPE STREQUAL "Debug") add_definitions(-D__RTMIDI_DEBUG__) if (CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") endif (CMAKE_COMPILER_IS_GNUCXX) endif () # Read libtool version info from configure.ac set(R "m4_define\\(\\[lt_([a-z]+)\\], ([0-9]+)\\)") file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/configure.ac" CONFIGAC REGEX ${R}) foreach(_S ${CONFIGAC}) string(REGEX REPLACE ${R} "\\1" k ${_S}) string(REGEX REPLACE ${R} "\\2" v ${_S}) set(SO_${k} ${v}) endforeach() math(EXPR SO_current_minus_age "${SO_current} - ${SO_age}") set(SO_VER "${SO_current_minus_age}") set(FULL_VER "${SO_current_minus_age}.${SO_age}.${SO_revision}") # Read package version info from configure.ac set(R "AC_INIT\\(RtMidi, ([0-9\\.]+),.*\\)") file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/configure.ac" CONFIGAC REGEX ${R}) string(REGEX REPLACE ${R} "\\1" PACKAGE_VERSION ${CONFIGAC}) # Init variables set(rtmidi_SOURCES RtMidi.cpp RtMidi.h rtmidi_c.cpp rtmidi_c.h) set(LINKLIBS) set(PUBLICLINKLIBS) set(INCDIRS) set(PKGCONFIG_REQUIRES) set(LIBS_REQUIRES) set(API_DEFS) set(API_LIST) set(PACKAGE_DEPENDENCIES) # Tweak API-specific configuration. # Jack if(RTMIDI_API_JACK) if (NOT HAVE_JACK) message(FATAL_ERROR "Jack API requested but no Jack dev libraries found") endif() set(NEED_PTHREAD ON) list(APPEND PKGCONFIG_REQUIRES "jack") list(APPEND API_DEFS "-D__UNIX_JACK__") list(APPEND API_LIST "jack") if(jack_FOUND) list(APPEND LINKLIBS ${jack_LIBRARIES}) list(APPEND INCDIRS ${jack_INCLUDEDIR}) else() list(APPEND LINKLIBS ${JACK_LIB}) endif() # Check for jack_port_rename include(CheckSymbolExists) set(tmp_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES}) list(APPEND CMAKE_REQUIRED_LIBRARIES jack) check_symbol_exists(jack_port_rename ${jack_INCLUDEDIR}/jack/jack.h JACK_HAS_PORT_RENAME) set(CMAKE_REQUIRED_LIBRARIES ${tmp_CMAKE_REQUIRED_LIBRARIES}) if(JACK_HAS_PORT_RENAME) list(APPEND API_DEFS "-DJACK_HAS_PORT_RENAME") endif() endif() # ALSA if(RTMIDI_API_ALSA) set(NEED_PTHREAD ON) find_package(ALSA) if (NOT ALSA_FOUND) message(FATAL_ERROR "ALSA API requested but no ALSA dev libraries found") endif() list(APPEND INCDIRS ${ALSA_INCLUDE_DIR}) list(APPEND LINKLIBS ALSA::ALSA) list(APPEND PKGCONFIG_REQUIRES "alsa") list(APPEND API_DEFS "-D__LINUX_ALSA__") list(APPEND API_LIST "alsa") list(APPEND PACKAGE_DEPENDENCIES "find_dependency(ALSA)") endif() # WinMM if(RTMIDI_API_WINMM) list(APPEND API_DEFS "-D__WINDOWS_MM__") list(APPEND API_LIST "winmm") list(APPEND LINKLIBS winmm) endif() # CoreMIDI if(RTMIDI_API_CORE) find_library(CORESERVICES_LIB CoreServices) find_library(COREAUDIO_LIB CoreAudio) find_library(COREMIDI_LIB CoreMIDI) find_library(COREFOUNDATION_LIB CoreFoundation) list(APPEND API_DEFS "-D__MACOSX_CORE__") list(APPEND API_LIST "coremidi") list(APPEND LINKLIBS ${CORESERVICES_LIB} ${COREAUDIO_LIB} ${COREMIDI_LIB} ${COREFOUNDATION_LIB}) list(APPEND LIBS_REQUIRES "-framework CoreServices -framework CoreAudio -framework CoreMIDI -framework CoreFoundation") list(APPEND LINKFLAGS "-Wl,-F/Library/Frameworks") endif() # pthread if (NEED_PTHREAD) find_package(Threads REQUIRED CMAKE_THREAD_PREFER_PTHREAD THREADS_PREFER_PTHREAD_FLAG) list(APPEND PUBLICLINKLIBS Threads::Threads) list(APPEND PACKAGE_DEPENDENCIES "find_dependency(Threads)") endif() # Create library targets. set(LIB_TARGETS) # Use RTMIDI_BUILD_SHARED_LIBS / RTMIDI_BUILD_STATIC_LIBS if they # are defined, otherwise default to standard BUILD_SHARED_LIBS. if (DEFINED RTMIDI_BUILD_SHARED_LIBS AND NOT RTMIDI_BUILD_SHARED_LIBS STREQUAL "") if (RTMIDI_BUILD_SHARED_LIBS) add_library(rtmidi SHARED ${rtmidi_SOURCES}) else() add_library(rtmidi STATIC ${rtmidi_SOURCES}) endif() elseif (DEFINED RTMIDI_BUILD_STATIC_LIBS AND NOT RTMIDI_BUILD_STATIC_LIBS STREQUAL "") if (RTMIDI_BUILD_STATIC_LIBS) add_library(rtmidi STATIC ${rtmidi_SOURCES}) else() add_library(rtmidi SHARED ${rtmidi_SOURCES}) endif() else() add_library(rtmidi ${rtmidi_SOURCES}) endif() list(APPEND LIB_TARGETS rtmidi) # Add headers destination for install rule. set_property(TARGET rtmidi PROPERTY PUBLIC_HEADER RtMidi.h rtmidi_c.h) set_target_properties(rtmidi PROPERTIES SOVERSION ${SO_VER} VERSION ${FULL_VER}) # Set standard installation directories. include(GNUInstallDirs) # Set include paths, populate target interface. target_include_directories(rtmidi PRIVATE ${INCDIRS} PUBLIC $ $) # Set compile-time definitions target_compile_definitions(rtmidi PRIVATE ${API_DEFS}) target_compile_definitions(rtmidi PRIVATE RTMIDI_EXPORT) target_link_libraries(rtmidi PUBLIC ${PUBLICLINKLIBS} PRIVATE ${LINKLIBS}) # Add tests if requested. option(RTMIDI_BUILD_TESTING "Build test programs" ON) if (NOT DEFINED RTMIDI_BUILD_TESTING OR RTMIDI_BUILD_TESTING STREQUAL "") set(RTMIDI_BUILD_TESTING ${BUILD_TESTING}) endif() if (RTMIDI_BUILD_TESTING) include(CTest) add_executable(cmidiin tests/cmidiin.cpp) add_executable(midiclock tests/midiclock.cpp) add_executable(midiout tests/midiout.cpp) add_executable(midiprobe tests/midiprobe.cpp) add_executable(qmidiin tests/qmidiin.cpp) add_executable(sysextest tests/sysextest.cpp) add_executable(apinames tests/apinames.cpp) add_executable(testcapi tests/testcapi.c) list(GET LIB_TARGETS 0 LIBRTMIDI) set_target_properties(cmidiin midiclock midiout midiprobe qmidiin sysextest apinames testcapi PROPERTIES RUNTIME_OUTPUT_DIRECTORY tests INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR} LINK_LIBRARIES ${LIBRTMIDI}) add_test(NAME apinames COMMAND apinames) endif() # Set standard installation directories. include(GNUInstallDirs) # Message string(REPLACE ";" " " apilist "${API_LIST}") message(STATUS "Compiling with support for: ${apilist}") # PkgConfig file string(REPLACE ";" " " req "${PKGCONFIG_REQUIRES}") string(REPLACE ";" " " req_libs "${LIBS_REQUIRES}") string(REPLACE ";" " " api "${API_DEFS}") set(prefix ${CMAKE_INSTALL_PREFIX}) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/rtmidi.pc.in" "rtmidi.pc" @ONLY) # Add install rule. install(TARGETS ${LIB_TARGETS} EXPORT RtMidiTargets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/rtmidi) # Store the package in the user registry. export(PACKAGE RtMidi) # Set installation path for CMake files. set(RTMIDI_CMAKE_DESTINATION share/rtmidi) # Export library target (build-tree). export(EXPORT RtMidiTargets NAMESPACE RtMidi::) # Export library target (install-tree). install(EXPORT RtMidiTargets DESTINATION ${RTMIDI_CMAKE_DESTINATION} NAMESPACE RtMidi::) # Configure uninstall target. configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RtMidiConfigUninstall.cmake.in" "${CMAKE_BINARY_DIR}/RtMidiConfigUninstall.cmake" @ONLY) # Create uninstall target. add_custom_target(${RTMIDI_TARGETNAME_UNINSTALL} COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/RtMidiConfigUninstall.cmake) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/rtmidi.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) # Set up CMake package include(CMakePackageConfigHelpers) # Write cmake package version file write_basic_package_version_file( rtmidi-config-version.cmake VERSION ${FULL_VER} COMPATIBILITY SameMajorVersion ) string(REPLACE ";" "\n" package_dependencies "${PACKAGE_DEPENDENCIES}") # Write cmake package config file configure_package_config_file ( cmake/rtmidi-config.cmake.in rtmidi-config.cmake INSTALL_DESTINATION "${RTMIDI_CMAKE_DESTINATION}" ) # Install package files install ( FILES "${CMAKE_CURRENT_BINARY_DIR}/rtmidi-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/rtmidi-config-version.cmake" DESTINATION "${RTMIDI_CMAKE_DESTINATION}" ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/LICENSE0000644000000000000000000000250514441703147014437 0ustar00 RtMidi: realtime MIDI i/o C++ classes Copyright (c) 2003-2021 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=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/Makefile.am0000644000000000000000000000102514441703147015462 0ustar00SUBDIRS = . tests if MAKE_DOC SUBDIRS += doc endif lib_LTLIBRARIES = %D%/librtmidi.la %C%_librtmidi_la_CXXFLAGS = -DRTMIDI_EXPORT %C%_librtmidi_la_LDFLAGS = -no-undefined -export-dynamic -version-info @SO_VERSION@ %C%_librtmidi_la_SOURCES = \ %D%/RtMidi.cpp \ %D%/rtmidi_c.cpp rtmidi_incdir = $(includedir)/rtmidi rtmidi_inc_HEADERS = \ %D%/RtMidi.h \ %D%/rtmidi_c.h pkgconfigdatadir = $(libdir)/pkgconfig pkgconfigdata_DATA = rtmidi.pc EXTRA_DIST = autogen.sh README.md msw rtmidi-config.in contrib cmake CMakeLists.txt ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/README.md0000644000000000000000000000453414441703147014715 0ustar00# RtMidi ![Build Status](https://github.com/thestk/rtmidi/actions/workflows/ci.yml/badge.svg) A set of C++ classes that provide a common API for realtime MIDI input/output across Linux (ALSA & JACK), Macintosh OS X (CoreMIDI & JACK) and Windows (Multimedia). By Gary P. Scavone, 2003-2021. This distribution of RtMidi contains the following: - `doc`: RtMidi documentation (also online at http://www.music.mcgill.ca/~gary/rtmidi/) - `tests`: example RtMidi programs On Unix systems, type `./configure` in the top level directory, then `make` in the `tests/` directory to compile the test programs. In Windows, open the Visual C++ workspace file located in the `tests/` directory. If you checked out the code from git, please run `./autogen.sh` before `./configure`. ## Overview RtMidi is a set of C++ classes (`RtMidiIn`, `RtMidiOut`, and API specific classes) that provide a common API (Application Programming Interface) for realtime MIDI input/output across Linux (ALSA, JACK), Macintosh OS X (CoreMIDI, JACK), and Windows (Multimedia Library) operating systems. RtMidi significantly simplifies the process of interacting with computer MIDI hardware and software. It was designed with the following goals: - object oriented C++ design - simple, common API across all supported platforms - only one header and one source file for easy inclusion in programming projects - MIDI device enumeration MIDI input and output functionality are separated into two classes, `RtMidiIn` and `RtMidiOut`. Each class instance supports only a single MIDI connection. RtMidi does not provide timing functionality (i.e., output messages are sent immediately). Input messages are timestamped with delta times in seconds (via a `double` floating point type). MIDI data is passed to the user as raw bytes using an `std::vector`. ## Windows In some cases, for example to use RtMidi with GS Synth, it may be necessary for your program to call `CoInitializeEx` and `CoUninitialize` on entry to and exit from the thread that uses RtMidi. ## Further reading For complete documentation on RtMidi, see the `doc` directory of the distribution or surf to http://www.music.mcgill.ca/~gary/rtmidi/. ## Legal and ethical The RtMidi license is similar to the MIT License, with the added *feature* that modifications be sent to the developer. Please see [LICENSE](LICENSE). ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/RtMidi.cpp0000644000000000000000000036757514441703147015353 0ustar00/**********************************************************************/ /*! \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-2021 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(__APPLE__) #include #endif #if (TARGET_OS_IPHONE == 1) #define AudioGetCurrentHostTime CAHostTimeBase::GetCurrentTime #define AudioConvertHostTimeToNanos CAHostTimeBase::ConvertToNanos #include class CTime2nsFactor { public: CTime2nsFactor() { mach_timebase_info_data_t tinfo; mach_timebase_info(&tinfo); Factor = (double)tinfo.numer / tinfo.denom; } static double Factor; }; double CTime2nsFactor::Factor; static CTime2nsFactor InitTime2nsFactor; #undef AudioGetCurrentHostTime #undef AudioConvertHostTimeToNanos #define AudioGetCurrentHostTime (uint64_t) mach_absolute_time #define AudioConvertHostTimeToNanos(t) t *CTime2nsFactor::Factor #define EndianS32_BtoN(n) n #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__) && !defined(TARGET_IPHONE_OS) && !defined(__WEB_MIDI_API__) #define __RTMIDI_DUMMY__ #endif #if defined(__MACOSX_CORE__) #include 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: MIDIClientRef getCoreMidiClientSingleton(const std::string& clientName) throw(); 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: MIDIClientRef getCoreMidiClientSingleton(const std::string& clientName) throw(); 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(__WEB_MIDI_API__) class MidiInWeb : public MidiInApi { std::string client_name{}; std::string web_midi_id{}; int open_port_number{-1}; public: MidiInWeb(const std::string &/*clientName*/, unsigned int queueSizeLimit ); ~MidiInWeb( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::WEB_MIDI_API; }; 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 onMidiMessage( uint8_t* data, double domHishResTimeStamp ); protected: void initialize( const std::string& clientName ); }; class MidiOutWeb: public MidiOutApi { std::string client_name{}; std::string web_midi_id{}; int open_port_number{-1}; public: MidiOutWeb( const std::string &clientName ); ~MidiOutWeb( void ); RtMidi::Api getCurrentApi( void ) { return RtMidi::WEB_MIDI_API; }; 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; } RtMidi::RtMidi(RtMidi&& other) noexcept { rtapi_ = other.rtapi_; other.rtapi_ = nullptr; } 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" }, { "web" , "Web MIDI API" }, { "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(__WEB_MIDI_API__) RtMidi::WEB_MIDI_API, #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 < RtMidi::UNSPECIFIED || api >= RtMidi::NUM_APIS) return ""; return rtmidi_api_names[api][0]; } std::string RtMidi :: getApiDisplayName( RtMidi::Api api ) { if (api < RtMidi::UNSPECIFIED || 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(__WEB_MIDI_API__) if ( api == WEB_MIDI_API ) rtapi_ = new MidiInWeb( 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(__WEB_MIDI_API__) if ( api == WEB_MIDI_API ) rtapi_ = new MidiOutWeb( 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; } void MidiInApi :: setBufferSize( unsigned int size, unsigned int count ) { inputData_.bufferSize = size; inputData_.bufferCount = count; } 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. // These are not available on iOS. #if (TARGET_OS_IPHONE == 0) #include #include #endif // 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; }; static MIDIClientRef CoreMidiClientSingleton = 0; void RtMidi_setCoreMidiClientSingleton(MIDIClientRef client){ CoreMidiClientSingleton = client; } void RtMidi_disposeCoreMidiClientSingleton(){ if (CoreMidiClientSingleton == 0){ return; } MIDIClientDispose( CoreMidiClientSingleton ); CoreMidiClientSingleton = 0; } //*********************************************************************// // 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_); if ( data->endpoint ) MIDIEndpointDispose( data->endpoint ); delete data; } MIDIClientRef MidiInCore::getCoreMidiClientSingleton(const std::string& clientName) throw() { if (CoreMidiClientSingleton == 0){ // 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 0; } CFRelease( name ); CoreMidiClientSingleton = client; } return CoreMidiClientSingleton; } void MidiInCore :: initialize( const std::string& clientName ) { // Set up our client. MIDIClientRef client = getCoreMidiClientSingleton(clientName); // Save our api-specific connection information. CoreMidiData *data = (CoreMidiData *) new CoreMidiData; data->client = client; data->endpoint = 0; apiData_ = (void *) data; inputData_.apiData = (void *) data; } 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 ) { 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 ); 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 ); 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 CreateEndpointName( 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 ); } // some MIDI devices have a leading space in endpoint name. trim CFStringTrim(result, CFSTR(" ")); 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 ); } } // 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 ); CFRetain( str ); 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 ); CFRetain( str ); return str; } else { if ( CFStringGetLength( str ) == 0 ) { 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 ); } } } return result; } // This function was submitted by Douglas Casey Tucker and apparently // derived largely from PortMidi. static CFStringRef CreateConnectedEndpointName( 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 = CreateConnectedEndpointName( 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_); if ( data->endpoint ) MIDIEndpointDispose( data->endpoint ); delete data; } MIDIClientRef MidiOutCore::getCoreMidiClientSingleton(const std::string& clientName) throw() { if (CoreMidiClientSingleton == 0){ // 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 0; } CFRelease( name ); CoreMidiClientSingleton = client; } return CoreMidiClientSingleton; } void MidiOutCore :: initialize( const std::string& clientName ) { // Set up our client. MIDIClientRef client = getCoreMidiClientSingleton(clientName); // Save our api-specific connection information. CoreMidiData *data = (CoreMidiData *) new CoreMidiData; data->client = client; data->endpoint = 0; apiData_ = (void *) data; } 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 = CreateConnectedEndpointName(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 ) { 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 ); 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; } if ( message[0] != 0xF0 && nBytes > 3 ) { errorString_ = "MidiOutCore::sendMessage: message format problem ... not sysex but > 3 bytes?"; error( RtMidiError::WARNING, errorString_ ); return; } MIDITimeStamp timeStamp = AudioGetCurrentHostTime(); CoreMidiData *data = static_cast (apiData_); OSStatus result; ByteCount bufsize = nBytes > 65535 ? 65535 : nBytes; Byte buffer[bufsize+16]; // pad for other struct members ByteCount listSize = sizeof( buffer ); MIDIPacketList *packetList = (MIDIPacketList*)buffer; ByteCount remainingBytes = nBytes; while ( remainingBytes ) { MIDIPacket *packet = MIDIPacketListInit( packetList ); // A MIDIPacketList can only contain a maximum of 64K of data, so if our message is longer, // break it up into chunks of 64K or less and send out as a MIDIPacketList with only one // MIDIPacket. Here, we reuse the memory allocated above on the stack for all. ByteCount bytesForPacket = remainingBytes > 65535 ? 65535 : remainingBytes; 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 int requestedBufferSize; 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; 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; data->bufferSize = inputData_.bufferSize; 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 ) { long 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; } } for ( unsigned int i=0; ibuffer[i] = message[i]; unsigned int offset = 0; while (offset < nBytes) { 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 ); result = snd_midi_event_encode( data->coder, data->buffer + offset, (long)(nBytes - offset), &ev ); if ( result < 0 ) { errorString_ = "MidiOutAlsa::sendMessage: event parsing error!"; error( RtMidiError::WARNING, errorString_ ); return; } if ( ev.type == SND_SEQ_EVENT_NONE ) { errorString_ = "MidiOutAlsa::sendMessage: incomplete message!"; error( RtMidiError::WARNING, errorString_ ); return; } offset += result; // 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 8196 #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; std::vector sysexBuffer; 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. data->sysexBuffer.resize( inputData_.bufferCount ); for ( unsigned int i=0; i < inputData_.bufferCount; ++i ) { data->sysexBuffer[i] = (MIDIHDR*) new char[ sizeof(MIDIHDR) ]; data->sysexBuffer[i]->lpData = new char[ inputData_.bufferSize ]; data->sysexBuffer[i]->dwBufferLength = inputData_.bufferSize; 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 ( size_t i=0; i < data->sysexBuffer.size(); ++i ) { int result = midiInUnprepareHeader(data->inHandle, 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_); // Disabled because midiOutReset triggers 0x7b (if any note was ON) and 0x79 "Reset All // Controllers" (to all 16 channels) CC messages which is undesirable (see issue #222) // 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 #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 *buff; int buffMaxWrite; // actual writable size, usually 1 less than ringbuffer 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"; if (portName.size() >= (size_t)jack_port_name_size()) errorString_ += " (port name too long?)"; 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"; if (portName.size() >= (size_t)jack_port_name_size()) errorString_ += " (port name too long?)"; 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_peek( data->buff, (char *) &space, sizeof( space ) ) == sizeof(space) && jack_ringbuffer_read_space( data->buff ) >= sizeof(space) + space ) { jack_ringbuffer_read_advance( data->buff, sizeof(space) ); midiData = jack_midi_event_reserve( buff, 0, space ); if ( midiData ) jack_ringbuffer_read( data->buff, (char *) midiData, (size_t) space ); else jack_ringbuffer_read_advance( data->buff, (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->buff = jack_ringbuffer_create( JACK_RINGBUFFER_SIZE ); data->buffMaxWrite = (int) jack_ringbuffer_write_space( data->buff ); // 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->buff ); 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"; if (portName.size() >= (size_t)jack_port_name_size()) errorString_ += " (port name too long?)"; 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"; if (portName.size() >= (size_t)jack_port_name_size()) errorString_ += " (port name too long?)"; 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_); if ( size + sizeof(nBytes) > (size_t) data->buffMaxWrite ) return; while ( jack_ringbuffer_write_space(data->buff) < sizeof(nBytes) + size ) sched_yield(); // Write full message to buffer jack_ringbuffer_write( data->buff, ( char * ) &nBytes, sizeof( nBytes ) ); jack_ringbuffer_write( data->buff, ( const char * ) message, nBytes ); } #endif // __UNIX_JACK__ //*********************************************************************// // API: Web MIDI // // Written primarily by Atsushi Eno, February 2020. // // *********************************************************************// #if defined(__WEB_MIDI_API__) #include //*********************************************************************// // API: WEB MIDI // Class Definitions: WebMidiAccessShim //*********************************************************************// class WebMidiAccessShim { public: WebMidiAccessShim(); ~WebMidiAccessShim(); std::string getPortName( unsigned int portNumber, bool isInput ); }; std::unique_ptr shim{nullptr}; void ensureShim() { if ( shim.get() != nullptr ) return; shim.reset( new WebMidiAccessShim() ); } bool checkWebMidiAvailability() { ensureShim(); return MAIN_THREAD_EM_ASM_INT( { if ( typeof window._rtmidi_internals_waiting === "undefined" ) { console.log ( "Attempted to use Web MIDI API without trying to open it." ); return false; } if ( window._rtmidi_internals_waiting ) { console.log ( "Attempted to use Web MIDI API while it is being queried." ); return false; } if ( _rtmidi_internals_midi_access == null ) { console.log ( "Attempted to use Web MIDI API while it already turned out to be unavailable." ); return false; } return true; } ); } WebMidiAccessShim::WebMidiAccessShim() { MAIN_THREAD_ASYNC_EM_ASM( { if( typeof window._rtmidi_internals_midi_access !== "undefined" ) return; if( typeof window._rtmidi_internals_waiting !== "undefined" ) { console.log( "MIDI Access was requested while another request is in progress." ); return; } // define functions window._rtmidi_internals_get_port_by_number = function( portNumber, isInput ) { var midi = window._rtmidi_internals_midi_access; var devices = isInput ? midi.inputs : midi.outputs; var i = 0; for (var device of devices.values()) { if ( i == portNumber ) return device; i++; } console.log( "MIDI " + (isInput ? "input" : "output") + " device of portNumber " + portNumber + " is not found."); return null; }; window._rtmidi_internals_waiting = true; window.navigator.requestMIDIAccess( {"sysex": true} ).then( (midiAccess) => { window._rtmidi_internals_midi_access = midiAccess; window._rtmidi_internals_latest_message_timestamp = 0.0; window._rtmidi_internals_waiting = false; if( midiAccess == null ) { console.log ( "Could not get access to MIDI API" ); } } ); } ); } WebMidiAccessShim::~WebMidiAccessShim() { } std::string WebMidiAccessShim::getPortName( unsigned int portNumber, bool isInput ) { if( !checkWebMidiAvailability() ) return ""; char *ret = (char*) MAIN_THREAD_EM_ASM_INT( { var port = window._rtmidi_internals_get_port_by_number($0, $1); if( port == null) return null; var length = lengthBytesUTF8(port.name) + 1; var ret = _malloc(length); stringToUTF8(port.name, ret, length); return ret; }, portNumber, isInput); if (ret == nullptr) return ""; std::string s = ret; free(ret); return s; } //*********************************************************************// // API: WEB MIDI // Class Definitions: MidiInWeb //*********************************************************************// MidiInWeb::MidiInWeb( const std::string &clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit ) { initialize( clientName ); } MidiInWeb::~MidiInWeb( void ) { closePort(); } extern "C" void EMSCRIPTEN_KEEPALIVE rtmidi_onMidiMessageProc( MidiInApi::RtMidiInData* data, uint8_t* inputBytes, int32_t length, double domHighResTimeStamp ) { auto &message = data->message; message.bytes.resize(message.bytes.size() + length); memcpy(message.bytes.data(), inputBytes, length); // FIXME: handle timestamp if ( data->usingCallback ) { RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback; callback( message.timeStamp, &message.bytes, data->userData ); } } void MidiInWeb::openPort( unsigned int portNumber, const std::string &portName ) { if( !checkWebMidiAvailability() ) return; if (open_port_number >= 0) return; MAIN_THREAD_EM_ASM( { // In Web MIDI API world, there is no step to open a port, but we have to register the input callback instead. var input = window._rtmidi_internals_get_port_by_number($0, true); input.onmidimessage = function(e) { // In RtMidi world, timestamps are delta time from previous message, while in Web MIDI world // timestamps are relative to window creation time (i.e. kind of absolute time with window "epoch" time). var rtmidiTimestamp = window._rtmidi_internals_latest_message_timestamp == 0.0 ? 0.0 : e.timeStamp - window._rtmidi_internals_latest_message_timestamp; window._rtmidi_internals_latest_message_timestamp = e.timeStamp; Module.ccall( 'rtmidi_onMidiMessageProc', 'void', ['number', 'array', 'number', 'number'], [$1, e.data, e.data.length, rtmidiTimestamp] ); }; }, portNumber, &inputData_ ); open_port_number = portNumber; } void MidiInWeb::openVirtualPort( const std::string &portName ) { errorString_ = "MidiInWeb::openVirtualPort: this function is not implemented for the Web MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiInWeb::closePort( void ) { if( open_port_number < 0 ) return; MAIN_THREAD_EM_ASM( { var input = _rtmidi_internals_get_port_by_number($0, true); if( input == null ) { console.log( "Port #" + $0 + " could not be found."); return; } // unregister event handler input.onmidimessage = null; }, open_port_number ); open_port_number = -1; } void MidiInWeb::setClientName( const std::string &clientName ) { client_name = clientName; } void MidiInWeb::setPortName( const std::string &portName ) { errorString_ = "MidiInWeb::setPortName: this function is not implemented for the Web MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } unsigned int MidiInWeb::getPortCount( void ) { if( !checkWebMidiAvailability() ) return 0; return MAIN_THREAD_EM_ASM_INT( { return _rtmidi_internals_midi_access.inputs.size; } ); } std::string MidiInWeb::getPortName( unsigned int portNumber ) { if( !checkWebMidiAvailability() ) return ""; return shim->getPortName( portNumber, true ); } void MidiInWeb::initialize( const std::string& clientName ) { ensureShim(); setClientName( clientName ); } //*********************************************************************// // API: WEB MIDI // Class Definitions: MidiOutWeb //*********************************************************************// MidiOutWeb::MidiOutWeb( const std::string &clientName ) { initialize( clientName ); } MidiOutWeb::~MidiOutWeb( void ) { closePort(); } void MidiOutWeb::openPort( unsigned int portNumber, const std::string &portName ) { if( !checkWebMidiAvailability() ) return; if (open_port_number >= 0) return; // In Web MIDI API world, there is no step to open a port. open_port_number = portNumber; } void MidiOutWeb::openVirtualPort( const std::string &portName ) { errorString_ = "MidiOutWeb::openVirtualPort: this function is not implemented for the Web MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } void MidiOutWeb::closePort( void ) { // there is really nothing to do for output at JS side. open_port_number = -1; } void MidiOutWeb::setClientName( const std::string &clientName ) { client_name = clientName; } void MidiOutWeb::setPortName( const std::string &portName ) { errorString_ = "MidiOutWeb::setPortName: this function is not implemented for the Web MIDI API!"; error( RtMidiError::WARNING, errorString_ ); } unsigned int MidiOutWeb::getPortCount( void ) { if( !checkWebMidiAvailability() ) return 0; return MAIN_THREAD_EM_ASM_INT( { return _rtmidi_internals_midi_access.outputs.size; } ); } std::string MidiOutWeb::getPortName( unsigned int portNumber ) { if( !checkWebMidiAvailability() ) return ""; return shim->getPortName( portNumber, false ); } void MidiOutWeb::sendMessage( const unsigned char *message, size_t size ) { if( open_port_number < 0 ) return; MAIN_THREAD_EM_ASM( { var output = _rtmidi_internals_get_port_by_number( $0, false ); if( output == null ) { console.log( "Port #" + $0 + " could not be found."); return; } var buf = new ArrayBuffer ($2); var msg = new Uint8Array( buf ); msg.set( new Uint8Array( Module.HEAPU8.buffer.slice( $1, $1 + $2 ) ) ); output.send( msg ); }, open_port_number, message, size ); } void MidiOutWeb::initialize( const std::string& clientName ) { if ( shim.get() != nullptr ) return; shim.reset( new WebMidiAccessShim() ); setClientName( clientName ); } #endif // __WEB_MIDI_API__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/RtMidi.h0000644000000000000000000006470714441703147015007 0ustar00/**********************************************************************/ /*! \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-2021 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 "5.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 occurred 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 occurred. */ SYSTEM_ERROR, /*!< A system error occurred. */ THREAD_ERROR /*!< A thread error occurred. */ }; //! 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: RtMidi(RtMidi&& other) noexcept; //! 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. */ WEB_MIDI_API, /*!< W3C Web 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 occurred. /*! The callback function will be called whenever an error has occurred. 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_; /* Make the class non-copyable */ RtMidi(RtMidi& other) = delete; RtMidi& operator=(RtMidi& other) = delete; }; /**********************************************************************/ /*! \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 ); RtMidiIn(RtMidiIn&& other) noexcept : RtMidi(std::move(other)) { } //! 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 occurred. /*! The callback function will be called whenever an error has occurred. It is best to set the error callback function before opening a port. */ virtual void setErrorCallback( RtMidiErrorCallback errorCallback = NULL, void *userData = 0 ); //! Set maximum expected incoming message size. /*! For APIs that require manual buffer management, it can be useful to set the buffer size and buffer count when expecting to receive large SysEx messages. Note that currently this function has no effect when called after openPort(). The default buffer size is 1024 with a count of 4 buffers, which should be sufficient for most cases; as mentioned, this does not affect all API backends, since most either support dynamically scalable buffers or take care of buffer handling themselves. It is principally intended for users of the Windows MM backend who must support receiving especially large messages. */ virtual void setBufferSize( unsigned int size, unsigned int count ); 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" ); RtMidiOut(RtMidiOut&& other) noexcept : RtMidi(std::move(other)) { } //! 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 occurred. /*! The callback function will be called whenever an error has occurred. 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 ); virtual void setBufferSize( unsigned int size, unsigned int count ); // 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; unsigned int bufferSize; unsigned int bufferCount; // Default constructor. RtMidiInData() : ignoreFlags(7), doInput(false), firstMessage(true), apiData(0), usingCallback(false), userCallback(0), userData(0), continueSysex(false), bufferSize(1024), bufferCount(4) {} }; 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 void RtMidiIn :: setBufferSize( unsigned int size, unsigned int count ) { static_cast(rtapi_)->setBufferSize(size, count); } 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/autogen.sh0000755000000000000000000000550414441703147015435 0ustar00#!/bin/sh # Run this to generate all the initial makefiles, etc. srcdir=`dirname $0` test -z "$srcdir" && srcdir=. DIE=0 if test -z "$*"; then echo "**Warning**: I am going to run \`configure' with arguments for" echo "developer/maintainer mode. If you wish to pass extra arguments," echo "(such as --prefix), please specify them on the \`$0'" echo "command line." echo "If you wish to run configure yourself, please specify --no-configure." echo fi (test -f $srcdir/configure.ac) || { echo -n "**Error**: Directory "\`$srcdir\'" does not look like the" echo " top-level package directory" exit 1 } # Make some directories required by automake, if they don't exist if ! [ -d config ]; then mkdir -v config; fi if ! [ -d m4 ]; then mkdir -v m4; fi if ! autoreconf --version /dev/null 2>&1 then (autoconf --version) < /dev/null > /dev/null 2>&1 || { echo echo "**Error**: You must have \`autoconf' installed." echo "Download the appropriate package for your distribution," echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/" DIE=1 } (grep "^LT_INIT" $srcdir/configure.ac >/dev/null) && { (libtoolize --version) < /dev/null > /dev/null 2>&1 \ && LIBTOOLIZE=libtoolize || { (glibtoolize --version) < /dev/null > /dev/null 2>&1 \ && LIBTOOLIZE=glibtoolize || { echo echo "**Error**: You must have \`libtool' installed." echo "You can get it from: ftp://ftp.gnu.org/pub/gnu/" DIE=1 } } } (automake --version) < /dev/null > /dev/null 2>&1 || { echo echo "**Error**: You must have \`automake' installed." echo "You can get it from: ftp://ftp.gnu.org/pub/gnu/" DIE=1 NO_AUTOMAKE=yes } # if no automake, don't bother testing for aclocal test -n "$NO_AUTOMAKE" || (aclocal --version) < /dev/null > /dev/null 2>&1 || { echo echo "**Error**: Missing \`aclocal'. The version of \`automake'" echo "installed doesn't appear recent enough." echo "You can get automake from ftp://ftp.gnu.org/pub/gnu/" DIE=1 } if test "$DIE" -eq 1; then exit 1 fi case $CC in xlc ) am_opt=--include-deps;; esac echo "Running aclocal $aclocalinclude ..." aclocal $ACLOCAL_FLAGS || exit 1 echo "Running $LIBTOOLIZE ..." $LIBTOOLIZE || exit 1 echo "Running automake --gnu $am_opt ..." automake --add-missing --gnu $am_opt || exit 1 echo "Running autoconf ..." autoconf || exit 1 else # autoreconf instead echo "Running autoreconf --verbose --install ..." autoreconf --verbose --install || exit 1 fi if ( echo "$@" | grep -q -e "--no-configure" ); then NOCONFIGURE=1 fi conf_flags="--enable-maintainer-mode --enable-debug --disable-silent-rules" if test x$NOCONFIGURE = x; then echo Running $srcdir/configure $conf_flags "$@" ... $srcdir/configure $conf_flags "$@" \ && echo Now type \`make\' to compile. || exit 1 else echo Skipping configure process. fi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/cmake/RtMidiConfigUninstall.cmake.in0000644000000000000000000000165414441703147022335 0ustar00if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach(file ${files}) message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") if(EXISTS "$ENV{DESTDIR}${file}") exec_program( "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) if(NOT "${rm_retval}" STREQUAL 0) message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") endif(NOT "${rm_retval}" STREQUAL 0) else(EXISTS "$ENV{DESTDIR}${file}") message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") endif(EXISTS "$ENV{DESTDIR}${file}") endforeach(file) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/cmake/rtmidi-config.cmake.in0000644000000000000000000000042514441703147020653 0ustar00#.rst: # RtMidi # ------- # # The following import targets are created # # :: # # # RtMidi::rtmidi # # @PACKAGE_INIT@ include(CMakeFindDependencyMacro) @package_dependencies@ if(NOT TARGET rtmidi) include("${CMAKE_CURRENT_LIST_DIR}/RtMidiTargets.cmake") endif() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/configure.ac0000644000000000000000000002213314441703147015717 0ustar00# Process this file with autoconf to produce a configure script. AC_INIT(RtMidi, 5.0.0, gary.scavone@mcgill.ca, rtmidi) AC_CONFIG_AUX_DIR(config) AC_CONFIG_SRCDIR(RtMidi.cpp) AC_CONFIG_FILES([rtmidi-config rtmidi.pc Makefile tests/Makefile doc/Makefile doc/doxygen/Doxyfile]) AM_INIT_AUTOMAKE([1.14 -Wall -Werror foreign subdir-objects]) # libtool version: current:revision:age # # If the library source code has changed at all since the last update, then # increment revision (`c:r:a' becomes `c:r+1:a'). # # If any interfaces have been added, removed, or changed since the last update, # increment current, and set revision to 0. # # If any interfaces have been added since the last public release, then # increment age. # # If any interfaces have been removed since the last public release, then set # age to 0. m4_define([lt_current], 6) m4_define([lt_revision], 0) m4_define([lt_age], 0) m4_define([lt_version_info], [lt_current:lt_revision:lt_age]) m4_define([lt_current_minus_age], [m4_eval(lt_current - lt_age)]) SO_VERSION=lt_version_info AC_SUBST(SO_VERSION) AC_SUBST(LIBS) AC_SUBST(api) AC_SUBST(req) AC_SUBST(req_libs) api="" req="" req_libs="" # Fill GXX with something before test. GXX="no" # if the user did not provide any CXXFLAGS, we can override them AS_IF([test "x$CXXFLAGS" = "x" ], [override_cxx=yes], [override_cxx=no]) AS_IF([test "x$CFLAGS" = "x" ], [override_c=yes], [override_c=no]) # Check version number coherency between RtMidi.h and configure.ac AC_MSG_CHECKING([that version numbers are coherent]) RTMIDI_VERSION=`sed -n 's/#define RTMIDI_VERSION "\(.*\)"/\1/p' $srcdir/RtMidi.h` AS_IF( [test "x$RTMIDI_VERSION" != "x$PACKAGE_VERSION"], [AC_MSG_FAILURE([testing RTMIDI_VERSION==PACKAGE_VERSION failed, check that RtMidi.h defines RTMIDI_VERSION as "$PACKAGE_VERSION" or that the first line of configure.ac has been updated.])]) # Enable some nice automake features if they are available m4_ifdef([AM_MAINTAINER_MODE], [AM_MAINTAINER_MODE]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) # standards version m4_include([m4/ax_cxx_compile_stdcxx.m4]) AX_CXX_COMPILE_STDCXX(11, noext, mandatory) # configure flags AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug], [enable various debugging output])]) AC_ARG_WITH(jack, [AS_HELP_STRING([--with-jack], [choose JACK server support])]) AC_ARG_WITH(alsa, [AS_HELP_STRING([--with-alsa], [choose native ALSA sequencer API support (linux only)])]) AC_ARG_WITH(core, [AS_HELP_STRING([--with-core], [ choose CoreMIDI API support (mac only)])]) AC_ARG_WITH(winmm, [AS_HELP_STRING([--with-winmm], [ choose Windows MultiMedia (MM) API support (win32 only)])]) AC_ARG_WITH(winks, [AS_HELP_STRING([--with-winks], [ choose kernel streaming support (win32 only)])]) AC_ARG_WITH(webmidi, [AS_HELP_STRING([--with-webmidi], [ choose Web MIDI support])]) # Checks for programs. AC_PROG_CXX(g++ CC c++ cxx) AM_PROG_AR AC_PATH_PROG(AR, ar, no) AS_IF([test "x$AR" = "xno"], [ AC_MSG_ERROR([Could not find ar - needed to create a library]) ]) LT_INIT([win32-dll]) AC_CONFIG_MACRO_DIR([m4]) # Checks for header files. AC_HEADER_STDC #AC_CHECK_HEADERS(sys/ioctl.h unistd.h) # Check for POSIX semaphore support AC_CHECK_HEADER([semaphore.h], [ AC_CHECK_LIB(pthread, sem_init, AC_DEFINE([HAVE_SEMAPHORE],[1],[Define to 1 if you have POSIX semaphore support on your system.]), AC_MSG_WARN([POSIX semaphore support not found; data may be lost on closePort])) ]) # check for debug AC_MSG_CHECKING(whether to compile debug version) debugflags="" object_path=Release AS_CASE([${enable_debug}], [ yes ], [ AC_MSG_RESULT([yes]) CPPFLAGS="-D__RTMIDI_DEBUG ${CPPFLAGS}" debugflags="${debugflags} -g" object_path=Debug ], [ no ], [ AC_MSG_RESULT([no!]) debugflags="${debugflags} -O3" ], [ AC_MSG_RESULT([no]) ]) # For debugging and optimization ... overwrite default because it has both -g and -O2 AS_IF([test "x$debugflags" != x], AS_IF([test "x$override_cxx" = "xyes" ], CXXFLAGS="$CXXFLAGS $debugflags", CXXFLAGS="$debugflags $CXXFLAGS") AS_IF([test "x$override_c" = "xyes" ], CFLAGS="$CFLAGS $debugflags", CFLAGS="$debugflags $CFLAGS") ) # Check compiler and use -Wall if gnu. AS_IF([test "x$GXX" = "xyes"], [ CXXFLAGS="-Wall -Wextra ${CXXFLAGS}" ]) # Checks for doxygen AC_CHECK_PROG( DOXYGEN, [doxygen], [doxygen] ) AM_CONDITIONAL( MAKE_DOC, [test "x${DOXYGEN}" != x] ) # Copy doc files to build dir if necessary AC_CONFIG_LINKS( [doc/doxygen/footer.html:doc/doxygen/footer.html] ) AC_CONFIG_LINKS( [doc/doxygen/header.html:doc/doxygen/header.html] ) AC_CONFIG_LINKS( [doc/doxygen/tutorial.txt:doc/doxygen/tutorial.txt] ) AC_CONFIG_LINKS( [doc/images/ccrma.gif:doc/images/ccrma.gif] ) AC_CONFIG_LINKS( [doc/images/mcgill.gif:doc/images/mcgill.gif] ) # Checks for package options and external software AC_CANONICAL_HOST # Aggregate options into a single string. AS_IF([test "x$with_jack" = "xyes"], [systems="$systems jack"]) AS_IF([test "x$with_alsa" = "xyes"], [systems="$systems alsa"]) AS_IF([test "x$with_core" = "xyes"], [systems="$systems core"]) AS_IF([test "x$with_winmm" = "xyes"], [systems="$systems winmm"]) AS_IF([test "x$with_winks" = "xyes"], [systems="$systems winks"]) AS_IF([test "x$with_webmidi" = "xyes"], [systems="$systems webmidi"]) AS_IF([test "x$with_dummy" = "xyes"], [systems="$systems dummy"]) required=" $systems " # If none, assign defaults if any are known for this OS. # User must specified with-* options for any unknown OS. AS_IF([test "x$systems" = "x"], AS_CASE([$host], [*-*-linux*], [systems="alsa jack"], [*-*-gnu], [systems="jack"], [*-*-kfreebsd*-gnu], [systems="jack"], [*-apple*], [systems="core jack"], [*-mingw32*], [systems="winmm winks jack"], [*-mingw64*], [systems="winmm winks jack"] )) # If any were specifically requested disabled, do it. AS_IF([test "x$with_jack" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v jack`]) AS_IF([test "x$with_alsa" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v alsa`]) AS_IF([test "x$with_winmm" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v winmm`]) AS_IF([test "x$with_winks" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v winks`]) AS_IF([test "x$with_core" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v core`]) AS_IF([test "x$with_webmidi" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v webmidi`]) AS_IF([test "x$with_dummy" = "xno"], [systems=`echo $systems|tr ' ' \\\\n|grep -v dummy`]) systems=" `echo $systems|tr \\\\n ' '` " # For each MIDI system, check if it is selected and found. # Note: Order specified above is not necessarily respected. However, # *actual* priority is set at run-time, see RtMidiIn::openMidiApi and RtMidiOut::openMidiApi. # One AS_CASE per system, since they are not mutually-exclusive. AS_CASE(["$systems"], [*" jack "*], [ AC_CHECK_LIB(jack, jack_client_open, [api="$api -D__UNIX_JACK__" req="$req jack" need_pthread=yes found="$found Jack" LIBS="-ljack $LIBS"], AS_CASE(["$required"], [*" jack "*], AC_MSG_ERROR([JACK support requires the jack library!]))) AC_CHECK_LIB(jack, jack_port_rename, AC_DEFINE(JACK_HAS_PORT_RENAME), ) ]) AS_CASE(["$systems"], [*" alsa "*], [ AC_CHECK_LIB(asound, snd_seq_open, [api="$api -D__LINUX_ALSA__" req="$req alsa" need_pthread=yes found="$found ALSA" LIBS="-lasound $LIBS"], AS_CASE(["$required"], [*" alsa "*], AC_MSG_ERROR([ALSA support requires the asound library!]))) ]) AS_CASE(["$systems"], [*" core "*], [ AC_CHECK_HEADER(CoreMIDI/CoreMIDI.h, [api="$api -D__MACOSX_CORE__" req_libs="$req_libs -framework CoreMIDI -framework CoreAudio -framework CoreFoundation" need_pthread=yes found="$found CoreMIDI", LIBS="$LIBS -framework CoreMIDI -framework CoreFoundation -framework CoreAudio"], AS_CASE(["$required"], [*" core "*], AC_MSG_ERROR([CoreMIDI header files not found!]))) ]) AS_CASE(["$systems"], [*" winmm "*], [ AC_CHECK_HEADERS(windows.h mmsystem.h, [api="$api -D__WINDOWS_MM__" CPPFLAGS="-I$srcdir/include $CPPFLAGS" need_ole32=yes found="$found WinMM" api="$api -D__WINDOWS_MM__" LIBS="-lwinmm ${LIBS}"]) ]) AS_CASE(["$systems"], [*" winks "*], [ AC_CHECK_HEADERS(windows.h audioclient.h avrt.h mmdeviceapi.h, [api="$api -D__WINDOWS_WINKS__" CPPFLAGS="-I$srcdir/include $CPPFLAGS" need_ole32=yes found="$found kernel-streaming" api="$api -D__WINDOWS_WINKS__" LIBS="-lsetupapi -lksuser ${LIBS}"]) ]) AS_CASE(["$systems"], [*" webmidi "*], [ AC_CHECK_HEADERS(emscripten.h, [api="$api -D__WEB_MIDI_API__" found="$found Web MIDI"]) ]) AS_IF([test -n "$need_ole32"], [LIBS="-lole32 $LIBS"]) AS_IF([test -n "$need_pthread"],[ AC_MSG_CHECKING([for pthread]) AC_CHECK_LIB(pthread, pthread_create, , AC_MSG_ERROR([RtAudio requires the pthread library!]))]) AC_MSG_CHECKING([for MIDI API]) # Error case: no known realtime systems found. AS_IF([test x"$api" = "x"], [ AC_MSG_RESULT([none]) AC_MSG_ERROR([No known system type found for MIDI support!]) ], [ AC_MSG_RESULT([$found]) ]) CPPFLAGS="$CPPFLAGS $api" AC_OUTPUT chmod oug+x rtmidi-config ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/contrib/go/rtmidi/go.mod0000644000000000000000000000007314441703147020073 0ustar00module github.com/thestk/rtmidi/contrib/go/rtmidi go 1.14 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/contrib/go/rtmidi/rtmidi.go0000644000000000000000000002441014441703147020605 0ustar00package rtmidi /* #cgo CXXFLAGS: -g -std=c++11 #cgo LDFLAGS: -g #cgo linux CXXFLAGS: -D__LINUX_ALSA__ #cgo linux LDFLAGS: -lasound -pthread #cgo windows CXXFLAGS: -D__WINDOWS_MM__ #cgo windows LDFLAGS: -luuid -lksuser -lwinmm -lole32 #cgo darwin CXXFLAGS: -D__MACOSX_CORE__ #cgo darwin LDFLAGS: -framework CoreServices -framework CoreAudio -framework CoreMIDI -framework CoreFoundation #include #include #include "rtmidi_stub.h" extern void goMIDIInCallback(double ts, unsigned char *msg, size_t msgsz, void *arg); static inline void midiInCallback(double ts, const unsigned char *msg, size_t msgsz, void *arg) { goMIDIInCallback(ts, (unsigned char*) msg, msgsz, arg); } static inline void cgoSetCallback(RtMidiPtr in, int cb_id) { rtmidi_in_set_callback(in, midiInCallback, (void*)(uintptr_t) cb_id); } */ import "C" import ( "errors" "sync" "unsafe" ) // API is an enumeration of possible MIDI API specifiers. type API C.enum_RtMidiApi const ( // APIUnspecified searches for a working compiled API. APIUnspecified API = C.RTMIDI_API_UNSPECIFIED // APIMacOSXCore uses Macintosh OS-X CoreMIDI API. APIMacOSXCore API = C.RTMIDI_API_MACOSX_CORE // APILinuxALSA uses the Advanced Linux Sound Architecture API. APILinuxALSA API = C.RTMIDI_API_LINUX_ALSA // APIUnixJack uses the JACK Low-Latency MIDI Server API. APIUnixJack API = C.RTMIDI_API_UNIX_JACK // APIWindowsMM uses the Microsoft Multimedia MIDI API. APIWindowsMM API = C.RTMIDI_API_WINDOWS_MM // APIDummy is a compilable but non-functional API. APIDummy API = C.RTMIDI_API_RTMIDI_DUMMY ) // Format an API as a string func (api API) String() string { switch api { case APIUnspecified: return "unspecified" case APILinuxALSA: return "alsa" case APIUnixJack: return "jack" case APIMacOSXCore: return "coreaudio" case APIWindowsMM: return "winmm" case APIDummy: return "dummy" } return "?" } // CompiledAPI determines the available compiled MIDI APIs. func CompiledAPI() (apis []API) { n := C.rtmidi_get_compiled_api(nil, 0) capis := make([]C.enum_RtMidiApi, n, n) C.rtmidi_get_compiled_api(&capis[0], C.uint(n)) for _, capi := range capis { apis = append(apis, API(capi)) } return apis } // MIDI interface provides a common, platform-independent API for realtime MIDI // device enumeration and handling MIDI ports. type MIDI interface { OpenPort(port int, name string) error OpenVirtualPort(name string) error Close() error PortCount() (int, error) PortName(port int) (string, error) } // MIDIIn interface 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 Message() // method 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. type MIDIIn interface { MIDI API() (API, error) IgnoreTypes(midiSysex bool, midiTime bool, midiSense bool) error SetCallback(func(MIDIIn, []byte, float64)) error CancelCallback() error Message() ([]byte, float64, error) Destroy() } // MIDIOut interface 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. type MIDIOut interface { MIDI API() (API, error) SendMessage([]byte) error Destroy() } type midi struct { midi C.RtMidiPtr } // Open a MIDI input connection given by enumeration number. func (m *midi) OpenPort(port int, name string) error { p := C.CString(name) defer C.free(unsafe.Pointer(p)) C.rtmidi_open_port(m.midi, C.uint(port), p) if !m.midi.ok { return errors.New(C.GoString(m.midi.msg)) } return nil } // Create a virtual input port, with optional name, to allow software connections // (OS X, JACK and ALSA only). func (m *midi) OpenVirtualPort(name string) error { p := C.CString(name) defer C.free(unsafe.Pointer(p)) C.rtmidi_open_virtual_port(m.midi, p) if !m.midi.ok { return errors.New(C.GoString(m.midi.msg)) } return nil } // Return a string identifier for the specified MIDI input port number. func (m *midi) PortName(port int) (string, error) { bufLen := C.int(0) C.rtmidi_get_port_name(m.midi, C.uint(port), nil, &bufLen) if !m.midi.ok { return "", errors.New(C.GoString(m.midi.msg)) } if bufLen < 1 { return "", nil } bufOut := make([]byte, int(bufLen)) p := (*C.char)(unsafe.Pointer(&bufOut[0])) C.rtmidi_get_port_name(m.midi, C.uint(port), p, &bufLen) if !m.midi.ok { return "", errors.New(C.GoString(m.midi.msg)) } return string(bufOut[0 : bufLen-1]), nil } // Return the number of available MIDI input ports. func (m *midi) PortCount() (int, error) { n := C.rtmidi_get_port_count(m.midi) if !m.midi.ok { return 0, errors.New(C.GoString(m.midi.msg)) } return int(n), nil } // Close an open MIDI connection. func (m *midi) Close() error { C.rtmidi_close_port(C.RtMidiPtr(m.midi)) if !m.midi.ok { return errors.New(C.GoString(m.midi.msg)) } return nil } type midiIn struct { midi in C.RtMidiInPtr cb func(MIDIIn, []byte, float64) } type midiOut struct { midi out C.RtMidiOutPtr } // Open a default MIDIIn port. func NewMIDIInDefault() (MIDIIn, error) { in := C.rtmidi_in_create_default() if !in.ok { defer C.rtmidi_in_free(in) return nil, errors.New(C.GoString(in.msg)) } return &midiIn{in: in, midi: midi{midi: C.RtMidiPtr(in)}}, nil } // Open a single MIDIIn port using the given API. One can provide a // custom port name and a desired queue size for the incoming MIDI messages. func NewMIDIIn(api API, name string, queueSize int) (MIDIIn, error) { p := C.CString(name) defer C.free(unsafe.Pointer(p)) in := C.rtmidi_in_create(C.enum_RtMidiApi(api), p, C.uint(queueSize)) if !in.ok { defer C.rtmidi_in_free(in) return nil, errors.New(C.GoString(in.msg)) } return &midiIn{in: in, midi: midi{midi: C.RtMidiPtr(in)}}, nil } // Return the MIDI API specifier for the current instance of RtMidiIn. func (m *midiIn) API() (API, error) { api := C.rtmidi_in_get_current_api(m.in) if !m.in.ok { return APIUnspecified, errors.New(C.GoString(m.in.msg)) } return API(api), nil } // Close an open MIDI connection (if one exists). func (m *midiIn) Close() error { unregisterMIDIIn(m) if err := m.midi.Close(); err != nil { return err } C.rtmidi_in_free(m.in) return nil } // 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. func (m *midiIn) IgnoreTypes(midiSysex bool, midiTime bool, midiSense bool) error { C.rtmidi_in_ignore_types(m.in, C._Bool(midiSysex), C._Bool(midiTime), C._Bool(midiSense)) if !m.in.ok { return errors.New(C.GoString(m.in.msg)) } return nil } var ( mu sync.Mutex inputs = map[int]*midiIn{} ) func registerMIDIIn(m *midiIn) int { mu.Lock() defer mu.Unlock() for i := 0; ; i++ { if _, ok := inputs[i]; !ok { inputs[i] = m return i } } } func unregisterMIDIIn(m *midiIn) { mu.Lock() defer mu.Unlock() for i := 0; i < len(inputs); i++ { if inputs[i] == m { delete(inputs, i) return } } } func findMIDIIn(k int) *midiIn { mu.Lock() defer mu.Unlock() return inputs[k] } //export goMIDIInCallback func goMIDIInCallback(ts C.double, msg *C.uchar, msgsz C.size_t, arg unsafe.Pointer) { k := int(uintptr(arg)) m := findMIDIIn(k) m.cb(m, C.GoBytes(unsafe.Pointer(msg), C.int(msgsz)), float64(ts)) } // Set a callback function to be invoked for incoming MIDI messages. func (m *midiIn) SetCallback(cb func(MIDIIn, []byte, float64)) error { k := registerMIDIIn(m) m.cb = cb C.cgoSetCallback(m.in, C.int(k)) if !m.in.ok { return errors.New(C.GoString(m.in.msg)) } return nil } // Cancel use of the current callback function (if one exists). func (m *midiIn) CancelCallback() error { unregisterMIDIIn(m) C.rtmidi_in_cancel_callback(m.in) if !m.in.ok { return errors.New(C.GoString(m.in.msg)) } return nil } // Fill a byte buffer with 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. func (m *midiIn) Message() ([]byte, float64, error) { msg := make([]C.uchar, 64*1024, 64*1024) sz := C.size_t(len(msg)) r := C.rtmidi_in_get_message(m.in, &msg[0], &sz) if !m.in.ok { return nil, 0, errors.New(C.GoString(m.in.msg)) } b := make([]byte, int(sz), int(sz)) for i, c := range msg[:sz] { b[i] = byte(c) } return b, float64(r), nil } func (m *midiIn) Destroy() { C.rtmidi_in_free(m.in) } // Open a default MIDIOut port. func NewMIDIOutDefault() (MIDIOut, error) { out := C.rtmidi_out_create_default() if !out.ok { defer C.rtmidi_out_free(out) return nil, errors.New(C.GoString(out.msg)) } return &midiOut{out: out, midi: midi{midi: C.RtMidiPtr(out)}}, nil } // Open a single MIDIIn port using the given API with the given port name. func NewMIDIOut(api API, name string) (MIDIOut, error) { p := C.CString(name) defer C.free(unsafe.Pointer(p)) out := C.rtmidi_out_create(C.enum_RtMidiApi(api), p) if !out.ok { defer C.rtmidi_out_free(out) return nil, errors.New(C.GoString(out.msg)) } return &midiOut{out: out, midi: midi{midi: C.RtMidiPtr(out)}}, nil } // Return the MIDI API specifier for the current instance of RtMidiOut. func (m *midiOut) API() (API, error) { api := C.rtmidi_out_get_current_api(m.out) if !m.out.ok { return APIUnspecified, errors.New(C.GoString(m.out.msg)) } return API(api), nil } // Close an open MIDI connection. func (m *midiOut) Close() error { if err := m.midi.Close(); err != nil { return err } C.rtmidi_out_free(m.out) return nil } // Immediately send a single message out an open MIDI output port. func (m *midiOut) SendMessage(b []byte) error { p := C.CBytes(b) defer C.free(unsafe.Pointer(p)) C.rtmidi_out_send_message(m.out, (*C.uchar)(p), C.int(len(b))) if !m.out.ok { return errors.New(C.GoString(m.out.msg)) } return nil } func (m *midiOut) Destroy() { C.rtmidi_out_free(m.out) } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/contrib/go/rtmidi/rtmidi_stub.cpp0000644000000000000000000000017514441703147022021 0ustar00#include "../../../RtMidi.h" #define RTMIDI_SOURCE_INCLUDED #include "../../../RtMidi.cpp" #include "../../../rtmidi_c.cpp" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/contrib/go/rtmidi/rtmidi_stub.h0000644000000000000000000000003714441703147021463 0ustar00#include "../../../rtmidi_c.h" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/contrib/go/rtmidi/rtmidi_test.go0000644000000000000000000000136614441703147021651 0ustar00package rtmidi import ( "log" ) func ExampleCompiledAPI() { for _, api := range CompiledAPI() { log.Println("Compiled API: ", api) } } func ExampleMIDIIn_Message() { in, err := NewMIDIInDefault() if err != nil { log.Fatal(err) } defer in.Destroy() if err := in.OpenPort(0, "RtMidi"); err != nil { log.Fatal(err) } defer in.Close() for { m, t, err := in.Message() if len(m) > 0 { log.Println(m, t, err) } } } func ExampleMIDIIn_SetCallback() { in, err := NewMIDIInDefault() if err != nil { log.Fatal(err) } defer in.Destroy() if err := in.OpenPort(0, "RtMidi"); err != nil { log.Fatal(err) } defer in.Close() in.SetCallback(func(m MIDIIn, msg []byte, t float64) { log.Println(msg, t) }) <-make(chan struct{}) } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/Makefile.am0000644000000000000000000000125214441703147016231 0ustar00 MAINTAINERCLEANFILES=Makefile.in CLEANFILES=doxygen-build.stamp DOX=Doxyfile EXTRA_DIST=html release.txt INSTIMAGES=html/doxygen.png DOC_STAMPS=doxygen-build.stamp DOC_DIR=$(HTML_DIR) all-local: doxygen-build.stamp doxygen-build.stamp: doxygen/$(DOX) $(top_srcdir)/RtMidi.h $(top_srcdir)/rtmidi_c.h @echo '*** Running doxygen ***' cd doxygen; $(DOXYGEN) $(DOX) touch doxygen-build.stamp clean-local: rm -f *~ *.bak $(DOC_STAMPS) || true if test -d html; then rm -fr html; fi if test -d latex; then rm -fr latex; fi if test -d man; then rm -fr man; fi distclean-local: clean rm -f *.stamp || true if test -d html; then rm -rf html; fi html-local: $(DOC_STAMPS) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/doxygen/Doxyfile.in0000644000000000000000000023640314441703147017775 0ustar00# Doxyfile 1.8.3.1 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # http://www.gnu.org/software/libiconv for the list of possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or sequence of words) that should # identify the project. Note that if you do not use Doxywizard you need # to put quotes around the project name if it contains spaces. PROJECT_NAME = RtMidi # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = @PACKAGE_VERSION@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer # a quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify an logo or icon that is # included in the documentation. The maximum height of the logo should not # exceed 55 pixels and the maximum width should not exceed 200 pixels. # Doxygen will copy the logo to the output directory. PROJECT_LOGO = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = . # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = NO # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. Note that you specify absolute paths here, but also # relative paths, which will be relative from the directory where doxygen is # started. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful if your file system # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like regular Qt-style comments # (thus requiring an explicit @brief command for a brief description.) JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then Doxygen will # interpret the first line (until the first dot) of a Qt-style # comment as the brief description. If set to NO, the comments # will behave just like regular Qt-style comments (thus requiring # an explicit \brief command for a brief description.) QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = YES # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding # "class=itcl::class" will allow you to use the command class in the # itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for # Java. For instance, namespaces will be presented as packages, qualified # scopes will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources only. Doxygen will then generate output that is more tailored for # Fortran. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for # VHDL. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, # and language is one of the parsers supported by doxygen: IDL, Java, # Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, # C++. For instance to make doxygen treat .inc files as Fortran files (default # is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note # that for custom extensions you also need to set FILE_PATTERNS otherwise the # files are not read by doxygen. EXTENSION_MAPPING = # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all # comments according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you # can mix doxygen, HTML, and XML commands with Markdown formatting. # Disable only in case of backward compatibilities issues. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented classes, # or namespaces to their corresponding documentation. Such a link can be # prevented in individual cases by by putting a % sign in front of the word or # globally by setting AUTOLINK_SUPPORT to NO. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also makes the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. # Doxygen will parse them like normal C++ but will assume all classes use public # instead of private inheritance when no explicit protection keyword is present. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES (the # default) will make doxygen replace the get and set methods by a property in # the documentation. This will only work if the methods are indeed getting or # setting a simple type. If this is not the case, or you want to show the # methods anyway, you should set this option to NO. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and # unions are shown inside the group in which they are included (e.g. using # @ingroup) instead of on a separate page (for HTML and Man pages) or # section (for LaTeX and RTF). INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and # unions with only public data fields will be shown inline in the documentation # of the scope in which they are defined (i.e. file, namespace, or group # documentation), provided this scope is documented. If set to NO (the default), # structs, classes, and unions are shown on a separate page (for HTML and Man # pages) or section (for LaTeX and RTF). INLINE_SIMPLE_STRUCTS = YES # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum # is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically # be useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. TYPEDEF_HIDES_STRUCT = YES # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to # determine which symbols to keep in memory and which to flush to disk. # When the cache is full, less often used symbols will be written to disk. # For small to medium size projects (<1000 input files) the default value is # probably good enough. For larger projects a too small cache size can cause # doxygen to be busy swapping symbols to and from disk most of the time # causing a significant performance penalty. # If the system has enough physical memory increasing the cache will improve the # performance by keeping more symbols in memory. Note that the value works on # a logarithmic scale so increasing the size by one will roughly double the # memory usage. The cache size is given by this formula: # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols. SYMBOL_CACHE_SIZE = 0 # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given # their name and scope. Since this can be an expensive process and often the # same symbol appear multiple times in the code, doxygen keeps a cache of # pre-resolved symbols. If the cache is too small doxygen will become slower. # If the cache is too large, memory is wasted. The cache size is given by this # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = NO # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal # scope will be included in the documentation. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = NO # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base # name of the file that contains the anonymous namespace. By default # anonymous namespaces are hidden. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = YES # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen # will list include files with double quotes in the documentation # rather than with sharp brackets. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = NO # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen # will sort the (brief and detailed) documentation of class members so that # constructors and destructors are listed first. If set to NO (the default) # the constructors will appear in the respective orders defined by # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the # hierarchy of group names into alphabetical order. If set to NO (the default) # the group names will appear in their defined order. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to # do proper type resolution of all parameters of a function it will reject a # match between the prototype and the implementation of a member function even # if there is only one candidate or it is obvious which candidate to choose # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen # will still accept a match between prototype and implementation in such cases. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if section-label ... \endif # and \cond section-label ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or macro consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and macros in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. # This will remove the Files entry from the Quick Index and from the # Folder Tree View (if specified). The default is YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the # Namespaces page. This will remove the Namespaces entry from the Quick Index # and from the Folder Tree View (if specified). The default is YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. # You can optionally specify a file name after the option, if omitted # DoxygenLayout.xml will be used as the name of the layout file. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files # containing the references data. This must be a list of .bib files. The # .bib extension is automatically appended if omitted. Using this command # requires the bibtex tool to be installed. See also # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this # feature you need bibtex and perl available in the search path. Do not use # file names with spaces, bibtex cannot handle them. CITE_BIB_FILES = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # The WARN_NO_PARAMDOC option can be enabled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = tutorial.txt \ @top_srcdir@/RtMidi.h \ @top_srcdir@/rtmidi_c.h # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is # also the default input encoding. Doxygen uses libiconv (or the iconv built # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for # the list of possible encodings. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py # *.f90 *.f *.for *.vhd *.vhdl FILE_PATTERNS = # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = samples # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty or if # non of the patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) # and it is also possible to disable source filtering for a specific pattern # using *.ext= (so without naming a filter). This option only has effect when # FILTER_SOURCE_FILES is enabled. FILTER_SOURCE_PATTERNS = # If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page (index.html). # This can be useful if you have a project on for instance GitHub and want reuse # the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C, C++ and Fortran comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = YES # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = NO # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = ../html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. Note that when using a custom header you are responsible # for the proper inclusion of any scripts and style sheets that doxygen # needs, which is dependent on the configuration options used. # It is advised to generate a default header using "doxygen -w html # header.html footer.html stylesheet.css YourConfigFile" and then modify # that header. Note that the header is subject to change so you typically # have to redo this when upgrading to a newer version of doxygen or when # changing the value of configuration settings such as GENERATE_TREEVIEW! HTML_HEADER = header.html # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = footer.html # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If left blank doxygen will # generate a default style sheet. Note that it is recommended to use # HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this # tag will in the future become obsolete. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional # user-defined cascading style sheet that is included after the standard # style sheets created by doxygen. Using this option one can overrule # certain style aspects. This is preferred over using HTML_STYLESHEET # since it does not replace the standard style sheet and is therefor more # robust against future updates. Doxygen will copy the style sheet file to # the output directory. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that # the files will be copied as-is; there are no commands or markers available. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. # Doxygen will adjust the colors in the style sheet and background images # according to this color. Hue is specified as an angle on a colorwheel, # see http://en.wikipedia.org/wiki/Hue for more information. # For instance the value 0 represents red, 60 is yellow, 120 is green, # 180 is cyan, 240 is blue, 300 purple, and 360 is red again. # The allowed range is 0 to 359. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of # the colors in the HTML output. For a value of 0 the output will use # grayscales only. A value of 255 will produce the most vivid colors. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to # the luminance component of the colors in the HTML output. Values below # 100 gradually make the output lighter, whereas values above 100 make # the output darker. The value divided by 100 is the actual gamma applied, # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, # and 100 does not change the gamma. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting # this to NO can help when comparing the output of multiple runs. HTML_TIMESTAMP = NO # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of # entries shown in the various tree structured indices initially; the user # can expand and collapse entries dynamically later on. Doxygen will expand # the tree to such a level that at most the specified number of entries are # visible (unless a fully collapsed tree already exceeds this amount). # So setting the number of entries 1 will produce a full collapsed tree by # default. 0 is a special value representing an infinite number of entries # and will result in a full expanded tree by default. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files # will be generated that can be used as input for Apple's Xcode 3 # integrated development environment, introduced with OSX 10.5 (Leopard). # To create a documentation set, doxygen will generate a Makefile in the # HTML output directory. Running make will produce the docset in that # directory and running "make install" will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find # it at startup. # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. GENERATE_DOCSET = NO # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the # feed. A documentation feed provides an umbrella under which multiple # documentation sets from a single provider (such as a company or product suite) # can be grouped. DOCSET_FEEDNAME = "Doxygen generated docs" # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that # should uniquely identify the documentation set bundle. This should be a # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen # will append .docset to the name. DOCSET_BUNDLE_ID = org.doxygen.Project # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely # identify the documentation publisher. This should be a reverse domain-name # style string, e.g. com.mycompany.MyDocSet.documentation. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compiled HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING # is used to encode HtmlHelp index (hhk), content (hhc) and project file # content. CHM_INDEX_ENCODING = # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated # that can be used as input for Qt's qhelpgenerator to generate a # Qt Compressed Help (.qch) of the generated HTML documentation. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can # be used to specify the file name of the resulting .qch file. # The path specified is relative to the HTML output folder. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#namespace QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#virtual-folders QHP_VIRTUAL_FOLDER = doc # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to # add. For more information please see # http://doc.trolltech.com/qthelpproject.html#custom-filters QHP_CUST_FILTER_NAME = # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see # # Qt Help Project / Custom Filters. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's # filter section matches. # # Qt Help Project / Filter Attributes. QHP_SECT_FILTER_ATTRS = # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can # be used to specify the location of Qt's qhelpgenerator. # If non-empty doxygen will try to run qhelpgenerator on the generated # .qhp file. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files # will be generated, which together with the HTML files, form an Eclipse help # plugin. To install this plugin and make it available under the help contents # menu in Eclipse, the contents of the directory containing the HTML and XML # files needs to be copied into the plugins directory of eclipse. The name of # the directory within the plugins directory should be the same as # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before # the help appears. GENERATE_ECLIPSEHELP = NO # A unique identifier for the eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have # this name. ECLIPSE_DOC_ID = org.doxygen.Project # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) # at top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. Since the tabs have the same information as the # navigation tree you can set this option to NO if you already set # GENERATE_TREEVIEW to YES. DISABLE_INDEX = YES # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. # If the tag value is set to YES, a side panel will be generated # containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). # Windows users are probably better off using the HTML help feature. # Since the tree basically has the same information as the tab index you # could consider to set DISABLE_INDEX to NO when enabling this option. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values # (range [0,1..20]) that doxygen will group on one line in the generated HTML # documentation. Note that a value of 0 will completely suppress the enum # values from appearing in the overview section. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open # links to external symbols imported via tag files in a separate window. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of Latex formulas included # as images in the HTML documentation. The default is 10. Note that # when you change the font size after a successful doxygen run you need # to manually remove any form_*.png images from the HTML output directory # to force them to be regenerated. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are # not supported properly for IE 6.0, but are supported on all modern browsers. # Note that when changing this option you need to delete any form_*.png files # in the HTML output before the changes have effect. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax # (see http://www.mathjax.org) which uses client side Javascript for the # rendering instead of using prerendered bitmaps. Use this if you do not # have LaTeX installed or if you want to formulas look prettier in the HTML # output. When enabled you may also need to install MathJax separately and # configure the path to it using the MATHJAX_RELPATH option. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # thA MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and # SVG. The default value is HTML-CSS, which is slower, but has the best # compatibility. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the # HTML output directory using the MATHJAX_RELPATH option. The destination # directory should contain the MathJax.js script. For instance, if the mathjax # directory is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to # the MathJax Content Delivery Network so you can quickly see the result without # installing MathJax. However, it is strongly recommended to install a local # copy of MathJax from http://www.mathjax.org before deployment. MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension # names that should be enabled during MathJax rendering. MATHJAX_EXTENSIONS = # When the SEARCHENGINE tag is enabled doxygen will generate a search box # for the HTML output. The underlying search engine uses javascript # and DHTML and should work on any modern browser. Note that when using # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets # (GENERATE_DOCSET) there is already a search function so this one should # typically be disabled. For large projects the javascript based search engine # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution. SEARCHENGINE = NO # When the SERVER_BASED_SEARCH tag is enabled the search engine will be # implemented using a web server instead of a web client using Javascript. # There are two flavours of web server based search depending on the # EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for # searching and an index file used by the script. When EXTERNAL_SEARCH is # enabled the indexing and searching needs to be provided by external tools. # See the manual for details. SERVER_BASED_SEARCH = NO # When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP # script for searching. Instead the search results are written to an XML file # which needs to be processed by an external indexer. Doxygen will invoke an # external search engine pointed to by the SEARCHENGINE_URL option to obtain # the search results. Doxygen ships with an example indexer (doxyindexer) and # search engine (doxysearch.cgi) which are based on the open source search engine # library Xapian. See the manual for configuration details. EXTERNAL_SEARCH = NO # The SEARCHENGINE_URL should point to a search engine hosted by a web server # which will returned the search results when EXTERNAL_SEARCH is enabled. # Doxygen ships with an example search engine (doxysearch) which is based on # the open source search engine library Xapian. See the manual for configuration # details. SEARCHENGINE_URL = # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed # search data is written to a file for indexing by an external tool. With the # SEARCHDATA_FILE tag the name of this file can be specified. SEARCHDATA_FILE = searchdata.xml # When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple # projects and redirect the results back to the right project. EXTERNAL_SEARCH_ID = # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen # projects other than the one defined by this configuration file, but that are # all added to the same external search index. Each project needs to have a # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id # of to a relative location where the documentation can be found. # The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ... EXTRA_SEARCH_MAPPINGS = #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = NO # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. # Note that when enabling USE_PDFLATEX this option is only used for # generating bitmaps for formulas in the HTML output, but not in the # Makefile that is written to the output directory. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = letter # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for # the generated latex document. The footer should contain everything after # the last chapter. If it is left blank doxygen will generate a # standard footer. Notice: only use this tag if you know what you are doing! LATEX_FOOTER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = NO # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = YES # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO # If LATEX_SOURCE_CODE is set to YES then doxygen will include # source code with syntax highlighting in the LaTeX output. # Note that which sources are shown also depends on other settings # such as SOURCE_BROWSER. LATEX_SOURCE_CODE = NO # The LATEX_BIB_STYLE tag can be used to specify the style to use for the # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See # http://en.wikipedia.org/wiki/BibTeX for more info. LATEX_BIB_STYLE = plain #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load style sheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. This is useful # if you want to understand what is going on. On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = NO # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_DEFINED tags. EXPAND_ONLY_PREDEF = NO # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # pointed to by INCLUDE_PATH will be searched when a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = __MACOSX_CORE__ \ __WINDOWS_MM__ \ __UNIX_JACK__ \ __LINUX_ALSA__ \ __WINDOWS_KS__ # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition that # overrules the definition found in the source code. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all references to function-like macros # that are alone on a line, have an all uppercase name, and do not end with a # semicolon, because these will confuse the parser if not removed. SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. For each # tag file the location of the external documentation should be added. The # format of a tag file without this location is as follows: # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths # or URLs. Note that each tag file must have a unique name (where the name does # NOT include the path). If a tag file is not located in the directory in which # doxygen is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option also works with HAVE_DOT disabled, but it is recommended to # install and use dot, since it yields more powerful graphs. CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the # documentation. The MSCGEN_PATH tag allows you to specify the directory where # the mscgen tool resides. If left empty the tool is assumed to be found in the # default search path. MSCGEN_PATH = /Applications/Doxygen.app/Contents/Resources/ # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = NO # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is # allowed to run in parallel. When set to 0 (the default) doxygen will # base this on the number of processors available in the system. You can set it # explicitly to a value larger than 0 to get control over the balance # between CPU load and processing speed. DOT_NUM_THREADS = 0 # By default doxygen will use the Helvetica font for all dot files that # doxygen generates. When you want a differently looking font you can specify # the font name using DOT_FONTNAME. You need to make sure dot is able to find # the font, which can be done by putting it in a standard location or by setting # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the # directory containing the font. DOT_FONTNAME = FreeSans # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. # The default size is 10pt. DOT_FONTSIZE = 10 # By default doxygen will tell dot to use the Helvetica font. # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to # set the path where dot can find it. DOT_FONTPATH = # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If the UML_LOOK tag is enabled, the fields and methods are shown inside # the class node. If there are many fields or methods and many nodes the # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS # threshold limits the number of items for each type to make the size more # managable. Set this to 0 for no limit. Note that the threshold may be # exceeded by 50% before the limit is enforced. UML_LIMIT_NUM_FIELDS = 10 # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = YES # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH and HAVE_DOT options are set to YES then # doxygen will generate a call dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable call graphs # for selected functions only using the \callgraph command. CALL_GRAPH = NO # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then # doxygen will generate a caller dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable caller # graphs for selected functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will generate a graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are svg, png, jpg, or gif. # If left blank png will be used. If you choose svg you need to set # HTML_FILE_EXTENSION to xhtml in order to make the SVG files # visible in IE 9+ (other browsers do not have this requirement). DOT_IMAGE_FORMAT = png # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to # enable generation of interactive SVG images that allow zooming and panning. # Note that this requires a modern browser other than Internet Explorer. # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files # visible. Older versions of IE do not have SVG support. INTERACTIVE_SVG = NO # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = /Applications/Doxygen.app/Contents/Resources/ # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The MSCFILE_DIRS tag can be used to specify one or more directories that # contain msc files that are included in the documentation (see the # \mscfile command). MSCFILE_DIRS = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen if the # number of direct children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. DOT_GRAPH_MAX_NODES = 50 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the # graphs generated by dot. A depth value of 3 means that only nodes reachable # from the root by following a path via at most 3 edges will be shown. Nodes # that lay further from the root node will be omitted. Note that setting this # option to 1 or 2 may greatly reduce the computation time needed for large # code bases. Also note that the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, because dot on Windows does not # seem to support this out of the box. Warning: Depending on the platform used, # enabling this option may lead to badly anti-aliased labels on the edges of # a graph (i.e. they become hard to read). DOT_TRANSPARENT = YES # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/doxygen/footer.html0000644000000000000000000000037614441703147020044 0ustar00
©2003-2021 Gary P. Scavone, McGill University. All Rights Reserved.
Maintained by Gary P. Scavone, gary at music.mcgill.ca
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/doxygen/header.html0000644000000000000000000000075614441703147020000 0ustar00 The RtMidi Tutorial
Tutorial   Class/Enum List   File List   Compound Members   C interface  
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/doxygen/samples/getting_started.cpp0000644000000000000000000000025514441703147023213 0ustar00#include "RtMidi.h" int main() { try { RtMidiIn midiin; } catch (RtMidiError &error) { // Handle the exception here error.printMessage(); } return 0; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/doxygen/tutorial.txt0000644000000000000000000005232514441703147020265 0ustar00/*! \mainpage The RtMidi Tutorial
\ref intro    \ref download    \ref start    \ref error    \ref probing    \ref output    \ref input    \ref virtual    \ref compiling    \ref debug    \ref multi    \ref apinotes    \ref acknowledge    \ref license
\section intro Introduction RtMidi is a set of C++ classes (RtMidiIn, RtMidiOut and API-specific classes) that provides a common API (Application Programming Interface) for realtime MIDI input/output across Linux (ALSA & JACK), Macintosh OS X (CoreMIDI & JACK), and Windows (Multimedia Library) operating systems. RtMidi significantly simplifies the process of interacting with computer MIDI hardware and software. It was designed with the following goals: - object oriented C++ design - simple, common API across all supported platforms - only one header and one source file for easy inclusion in programming projects - MIDI device enumeration Where applicable, multiple API support can be compiled and a particular API specified when creating an RtAudio instance. MIDI input and output functionality are separated into two classes, RtMidiIn and RtMidiOut. Each class instance supports only a single MIDI connection. RtMidi does not provide timing functionality (i.e., output messages are sent immediately). Input messages are timestamped with delta times in seconds (via a \c double floating point type). MIDI data is passed to the user as raw bytes using an std::vector. \section whatsnew What's New (Version 5.0.0) The version number has been bumped to 5.0.0 because a new API (Web MIDI) was added, as well as at least one new function. Changes in this release include: - see git history for complete list of changes - new Web MIDI API - iOS support - new setBufferSize() function - fixes for WinMM, Jack - added C API test program - now requiring C++11 - build system updates - midiprobe probes all compiled APIs - various build system updates and code efficiencies \section download Download Latest Release (16 November 2021): Version 5.0.0 \section start Getting Started The first thing that must be done when using RtMidi is to create an instance of the RtMidiIn or RtMidiOut subclasses. RtMidi is an abstract base class, which itself cannot be instantiated. Each default constructor attempts to establish any necessary "connections" with the underlying MIDI system. RtMidi uses C++ exceptions to report errors, necessitating try/catch blocks around many member functions. An RtMidiError can be thrown during instantiation in some circumstances. A warning message may also be reported if no MIDI devices are found during instantiation. The RtMidi classes have been designed to work with "hot pluggable" or virtual (software) MIDI devices, making it possible to connect to MIDI devices that may not have been present when the classes were instantiated. The following code example demonstrates default object construction and destruction: \include getting_started.cpp Obviously, this example doesn't demonstrate any of the real functionality of RtMidi. However, all uses of RtMidi must begin with construction and must end with class destruction. Further, it is necessary that all class methods that can throw a C++ exception be called within a try/catch block. \section error Error Handling RtMidi uses a C++ exception handler called RtMidiError, which is declared and defined in RtMidi.h. The RtMidiError class is quite simple but it does allow errors to be "caught" by RtMidiError::Type. Many RtMidi methods can "throw" an RtMidiError, most typically if a driver error occurs or an invalid function argument is specified. There are a number of cases within RtMidi where warning messages may be displayed but an exception is not thrown. A client error callback function can be specified (via the RtMidi::setErrorCallback function) that is invoked when an error occurs. By default, error messages are not automatically displayed in RtMidi unless the preprocessor definition __RTMIDI_DEBUG__ is defined during compilation. Messages associated with caught exceptions can be displayed with, for example, the RtMidiError::printMessage() function. \section probing Probing Ports / Devices A client generally must query the available MIDI ports before deciding which to use. The following example outlines how this can be done. \code // midiprobe.cpp #include #include #include "RtMidi.h" int main() { RtMidiIn *midiin = 0; RtMidiOut *midiout = 0; // RtMidiIn constructor try { midiin = new RtMidiIn(); } catch ( RtMidiError &error ) { error.printMessage(); exit( EXIT_FAILURE ); } // Check inputs. unsigned int nPorts = midiin->getPortCount(); std::cout << "\nThere are " << nPorts << " MIDI input sources available.\n"; std::string portName; for ( unsigned int i=0; igetPortName(i); } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } std::cout << " Input Port #" << i+1 << ": " << portName << '\n'; } // RtMidiOut constructor try { midiout = new RtMidiOut(); } catch ( RtMidiError &error ) { error.printMessage(); exit( EXIT_FAILURE ); } // Check outputs. nPorts = midiout->getPortCount(); std::cout << "\nThere are " << nPorts << " MIDI output ports available.\n"; for ( unsigned int i=0; igetPortName(i); } catch (RtMidiError &error) { error.printMessage(); goto cleanup; } std::cout << " Output Port #" << i+1 << ": " << portName << '\n'; } std::cout << '\n'; // Clean up cleanup: delete midiin; delete midiout; return 0; } \endcode Note that the port enumeration is system specific and will change if any devices are unplugged or plugged (or a new virtual port opened or closed) by the user. Thus, the port numbers should be verified immediately before opening a port. As well, if a user unplugs a device (or closes a virtual port) while a port connection exists to that device/port, a MIDI system error will be generated. \section output MIDI Output The RtMidiOut class provides simple functionality to immediately send messages over a MIDI connection. No timing functionality is provided. Note that there is an overloaded RtMidiOut::sendMessage() function that does not use std::vectors. In the following example, we omit necessary error checking and details regarding OS-dependent sleep functions. For a complete example, see the \c midiout.cpp program in the \c tests directory. \code // midiout.cpp #include #include #include "RtMidi.h" int main() { RtMidiOut *midiout = new RtMidiOut(); std::vector message; // Check available ports. unsigned int nPorts = midiout->getPortCount(); if ( nPorts == 0 ) { std::cout << "No ports available!\n"; goto cleanup; } // Open first available port. midiout->openPort( 0 ); // Send out a series of MIDI messages. // Program change: 192, 5 message.push_back( 192 ); message.push_back( 5 ); midiout->sendMessage( &message ); // Control Change: 176, 7, 100 (volume) message[0] = 176; message[1] = 7; message.push_back( 100 ); midiout->sendMessage( &message ); // Note On: 144, 64, 90 message[0] = 144; message[1] = 64; message[2] = 90; midiout->sendMessage( &message ); SLEEP( 500 ); // Platform-dependent ... see example in tests directory. // Note Off: 128, 64, 40 message[0] = 128; message[1] = 64; message[2] = 40; midiout->sendMessage( &message ); // Clean up cleanup: delete midiout; return 0; } \endcode \section input MIDI Input The RtMidiIn class uses an internal callback function or thread to receive incoming MIDI messages from a port or device. These messages are then either queued and read by the user via calls to the RtMidiIn::getMessage() function or immediately passed to a user-specified callback function (which must be "registered" using the RtMidiIn::setCallback() function). Note that if you have multiple instances of RtMidiIn, each may have its own thread. We'll provide examples of both usages. The RtMidiIn class provides the RtMidiIn::ignoreTypes() function to specify that certain MIDI message types be ignored. By default, system exclusive, timing, and active sensing messages are ignored. \subsection qmidiin Queued MIDI Input The RtMidiIn::getMessage() function does not block. If a MIDI message is available in the queue, it is copied to the user-provided \c std::vector container. When no MIDI message is available, the function returns an empty container. The default maximum MIDI queue size is 1024 messages. This value may be modified with the RtMidiIn::setQueueSizeLimit() function. If the maximum queue size limit is reached, subsequent incoming MIDI messages are discarded until the queue size is reduced. In the following example, we omit some necessary error checking and details regarding OS-dependent sleep functions. For a more complete example, see the \c qmidiin.cpp program in the \c tests directory. \code // qmidiin.cpp #include #include #include #include "RtMidi.h" bool done; static void finish(int ignore){ done = true; } int main() { RtMidiIn *midiin = new RtMidiIn(); std::vector message; int nBytes, i; double stamp; // Check available ports. unsigned int nPorts = midiin->getPortCount(); if ( nPorts == 0 ) { std::cout << "No ports available!\n"; goto cleanup; } midiin->openPort( 0 ); // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, false, false ); // Install an interrupt handler function. done = false; (void) signal(SIGINT, finish); // Periodically check input queue. std::cout << "Reading MIDI from port ... quit with Ctrl-C.\n"; while ( !done ) { stamp = midiin->getMessage( &message ); nBytes = message.size(); for ( i=0; i 0 ) std::cout << "stamp = " << stamp << std::endl; // Sleep for 10 milliseconds ... platform-dependent. SLEEP( 10 ); } // Clean up cleanup: delete midiin; return 0; } \endcode \subsection cmidiin MIDI Input with User Callback When set, a user-provided callback function will be invoked after the input of a complete MIDI message. It is possible to provide a pointer to user data that can be accessed in the callback function (not shown here). It is necessary to set the callback function immediately after opening the port to avoid having incoming messages written to the queue (which is not emptied when a callback function is set). If you are worried about this happening, you can check the queue using the RtMidi::getMessage() function to verify it is empty (after the callback function is set). In the following example, we omit some necessary error checking. For a more complete example, see the \c cmidiin.cpp program in the \c tests directory. \code // cmidiin.cpp #include #include #include "RtMidi.h" void mycallback( double deltatime, std::vector< unsigned char > *message, void *userData ) { unsigned int nBytes = message->size(); for ( unsigned int i=0; i 0 ) std::cout << "stamp = " << deltatime << std::endl; } int main() { RtMidiIn *midiin = new RtMidiIn(); // Check available ports. unsigned int nPorts = midiin->getPortCount(); if ( nPorts == 0 ) { std::cout << "No ports available!\n"; goto cleanup; } midiin->openPort( 0 ); // Set our callback function. This should be done immediately after // opening the port to avoid having incoming messages written to the // queue. midiin->setCallback( &mycallback ); // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, false, false ); std::cout << "\nReading MIDI input ... press to quit.\n"; char input; std::cin.get(input); // Clean up cleanup: delete midiin; return 0; } \endcode \section virtual Virtual Ports The Linux ALSA, Macintosh CoreMIDI and JACK APIs allow for the establishment of virtual input and output MIDI ports to which other software clients can connect. RtMidi incorporates this functionality with the RtMidiIn::openVirtualPort() and RtMidiOut::openVirtualPort() functions. Any messages sent with the RtMidiOut::sendMessage() function will also be transmitted through an open virtual output port. If a virtual input port is open and a user callback function is set, the callback function will be invoked when messages arrive via that port. If a callback function is not set, the user must poll the input queue to check whether messages have arrived. No notification is provided for the establishment of a client connection via a virtual port. The RtMidi::isPortOpen() function does not report the status of ports created with the RtMidi::openVirtualPort() function. \section compiling Compiling In order to compile RtMidi for a specific OS and API, it is necessary to supply the appropriate preprocessor definition and library within the compiler statement:

OS: MIDI API: Preprocessor Definition: Library or Framework: Example Compiler Statement:
Linux ALSA Sequencer __LINUX_ALSA__ asound, pthread g++ -Wall -D__LINUX_ALSA__ -o midiprobe midiprobe.cpp RtMidi.cpp -lasound -lpthread
Linux or Mac JACK MIDI __UNIX_JACK__ jack g++ -Wall -D__UNIX_JACK__ -o midiprobe midiprobe.cpp RtMidi.cpp -ljack
Macintosh OS X CoreMIDI __MACOSX_CORE__ CoreMIDI, CoreAudio, CoreFoundation g++ -Wall -D__MACOSX_CORE__ -o midiprobe midiprobe.cpp RtMidi.cpp -framework CoreMIDI -framework CoreAudio -framework CoreFoundation
Windows Multimedia Library __WINDOWS_MM__ winmm.lib, multithreaded compiler specific

The example compiler statements above could be used to compile the midiprobe.cpp example file, assuming that midiprobe.cpp, RtMidi.h and RtMidi.cpp all exist in the same directory. \section debug Debugging If you are having problems getting RtMidi to run on your system, try passing the preprocessor definition __RTMIDI_DEBUG__ to the compiler (or define it in RtMidi.h). A variety of warning messages will be displayed that may help in determining the problem. Also try using the programs included in the tests directory. The program midiprobe displays the queried capabilities of all MIDI ports found. \section multi Using Simultaneous Multiple APIs Support for each MIDI API is encapsulated in specific MidiInApi or MidiOutApi subclasses, making it possible to compile and instantiate multiple API-specific subclasses on a given operating system. For example, one can compile both CoreMIDI and JACK support on the OS-X operating system by providing the appropriate preprocessor definitions for each. In a run-time situation, one might first attempt to determine whether any JACK ports are available. This can be done by specifying the api argument RtMidi::UNIX_JACK when attempting to create an instance of RtMidiIn or RtMidiOut. If no available ports are found, then an instance of RtMidi with the api argument RtMidi::MACOSX_CORE can be created. Alternately, if no api argument is specified, RtMidi will first look for JACK ports and if none are found, then CoreMIDI ports (in linux, the search order is JACK and then ALSA. In theory, it should also be possible to have separate instances of RtMidi open at the same time with different underlying API support, though this has not been tested. The static function RtMidi::getCompiledApi() is provided to determine the available compiled API support. The function RtMidi::getCurrentApi() indicates the API selected for a given RtMidi instance. \section apinotes API Notes RtMidi is designed to provide a common API across the various supported operating systems and audio libraries. Despite that, some issues should be mentioned with regard to each. \subsection linux Linux: RtMidi for Linux was developed using the Fedora distribution. Two different MIDI APIs are supported on Linux platforms: ALSA and JACK. A decision was made to not include support for the OSS API because the OSS API provides very limited functionality and because ALSA support is now incorporated in the Linux kernel. The ALSA sequencer and JACK APIs allows for virtual software input and output ports. \subsection macosx Macintosh OS X (CoreAudio): The Apple CoreMIDI API allows for the establishment of virtual input and output ports to which other software applications can connect. The RtMidi JACK support can be compiled on Macintosh OS-X systems, as well as in Linux. \subsection windowsds Windows (Multimedia Library): The \c configure script provides support for the MinGW compiler. The Windows Multimedia library MIDI calls used in RtMidi do not make use of streaming functionality. Incoming system exclusive messages read by RtMidiIn are limited to a length as defined by the preprocessor definition RT_SYSEX_BUFFER_SIZE (set in RtMidi.cpp). The default value is 1024. There is no such limit for outgoing sysex messages via RtMidiOut. RtMidi was originally developed with Visual C++ version 6.0 but has been tested with Virtual Studio 2010. \section acknowledge Development & Acknowledgements RtMidi is on github (https://github.com/thestk/rtmidi). Many thanks to the developers that are helping to maintain and improve RtMidi. In years past, the following people provided bug fixes and improvements: - Stephen Sinclair (Git repo, code and build system) - amosonn - Christopher Arndt - Atsushi Eno (C API) - Sebastien Alaiwan (JACK memory leaks, Windows kernel streaming) - Jean-Baptiste Berruchon (Windows sysex code) - Pedro Lopez-Cabanillas (ALSA sequencer API, client naming) - Jason Champion (MSW project file for library build) - Chris Chronopoulos - JP Cimalando - Eduardo Coutinho (Windows device names) - Mattes D - Michael Dahl - Paul Dean (increment optimization) - Francisco Demartino - Luc Deschenaux (sysex issues) - John Dey (OS-X timestamps) - Christoph Eckert (ALSA sysex fixes) - Thiago Goulart - Ashley Hedges - Sam Hocevar - Rorey Jaffe - jgvictores - Martin Koegler (various fixes) - Immanuel Litzroth (OS-X sysex fix) - Bartek Lukawski - Andi McClure - Jon McCormack (Snow Leopard updates) - Phildo - Lane Spangler - Axel Schmidt (client naming) - Ryan Schmidt - Saga Musix - Bart Spaans - Alexander Svetalkin (JACK MIDI) - Ben Swift - Casey Tucker (OS-X driver information, sysex sending) - Bastiaan Verreijt (Windows sysex multi-buffer code) - Dan Wilcox - Yuri - Serge Zaitsev - Iohannes Zmölnig \section license 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=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/images/ccrma.gif0000644000000000000000000000670714441703147017230 0ustar00GIF89a$;}6o9hiX˞t|2d$f,^ $L 6~mzW`jkê-hϖ̇,qErþO{crlDf!]z'n;lwս&Hv 0m +a~(T{ڏ+zȮƈ [!;,$@pH,Ȥrl:(Bj6$qNC7Bn8 f4!gp++055#$)./4/.-- <> .chg 4**:?:<, B9953 ;#.?9:=?9=/?=#ρ =9 9=<|9W88?..9f#BQ! xX P р &F` ab.ach\Avq;"l sߏMG(UBTPZ(DATh f!?(悆G.Yxa"h⠊?Ԩc+Ft\%,B0(w&$3`)(^0dv8 <BM彰M) )A) f-` 6p #U/)@zt @##Br?rp=A,uG;hW灉iB aapfh j[?{UṚX0QC [T! (Y\KCa\K0=0j%nmPI bi.a p uh@)ψhbmhza4ǩfLŇp>4TL5I#?Bы=m?h^4x X ų` 634^& г!ZP@5P6,zD}#cz%g9dYD1 ny2 pfƀ]&?@ўQPf 2Uz?9zfL /bvLZFZ''b50Ȟ RĠRi08RPZ?`>w!H=D܁A!lJҦ6Aj Zp z˯ Op$q]~ 6Vd[8DZZ+S\Սo ~g+^L%C)T 9We  4>Cp!Љ0@"LЃ6Lj?FoP ,HV;U%PZx'2Rc#lI1t!, ~SC%T Ät/eH3XYuURcVHWc1m[s51% Ƴ27B^05d$PT(\E8HsY 94waZE:.L&#UXa#[@VYXPyU&@>(W!82@\c3yuYWRCM2uZ@/`bWI f[[Ru]W N\(̥T ] bu]gR/"ٟP;././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/images/mcgill.gif0000644000000000000000000001100614441703147017376 0ustar00GIF89a9Xceogqfphqhrwwv~7IEUGUGWWcWdXeeqq}s~t~3I4H4J7JEW}}<= ;">#=;<>?13?#KBebr1340234>A?@A M#M0Y0Z0Y2Y3Z@e@fBfPsRsSt``bpr!,9G H*\ȰÇ#JHŋ3jȱǏ7e#H'K)'0cʜISK SN=yƱӳN9r!(PJ $BD˔YGO2`ckOD, շpԔ'eƋ Ġ .F* !Kr#K0Yq$Ss N pYfQMM5*SjjKv&FypR6؞F@1:'Fێ !kɜrTN9!$3ulZ)  qu‘&=5W qtP, BtxUg<$,4RK(QEoDRȌAH!7bFf\AkF9Hp8SZ=BF#}IBnL"Her`:$BRX@Wdpr0)] 4DP hC`Qȓ*) HnWu%č‰&,bY<5PO%e^m*9mBȒޭ&ud1v81 QqP(E7 i|EdQ YGQ=EOI4k }H}A`RQ& Xi=:&`œ^)bTReAS '$JR`A9`;xvF=1 ? ?^!uFVWsC}UvLoRGBQK+>MbEu ]y!9`440FfD0LP/$( ڂP(] sDEP^&J.VCw՜h YXm0d gGѹ@s%oۛ $=pI wő @"qLQ!T-T?W'{7ՅuCR# dɱP8F6H(< Q^Sv (P#V&GEWq†",A\YtFIj]38Tg29A@wOMh(]EP@p2\I Z䲃%:D(qFBV:?:Ȑ! 7RRaP2ãœqf fH|ȃpglii@%q"hR0Eh!#% 1 3#O8dBAE]fxQbr!Å ‰;)N{`P|\) "ȳT( R8@qx^^p/ؾ)C‰ŁoшRlb@ɌB;431 d! ٛ Ȑ9!(;gr4& O\'Y=IU,- ObD4 sD.QXd  p2/ Yp(b S܀?đLy8?DC z')?oQU["b#ToVy5`zP , 0=TB)ȐY0<=Nu0C!6}yYBff֐"$B`(pZ X! 0&cSL!+ _=e$z7[Nf8n4#3DA@.9y+H.kJKZ|p!|(.6C^ mMWTa2srhB4@,1J5!0*1HC'$gaV@|kyW‡~2fr4 ff&r,'+kY'(ItX48LM/N'FC֡2 p4˄ `0p8u 1Rwt$}`Z&@(e#@B.bWE'"^+6 F sgQqm}Y@<#pӂd.geaD+3m 226|gA@N$!@5]@L(='`nx$rxdMA6 =&!>I=>T2 RT% `&X c 8ǒ,5R(\BDh60Z:ZYp Dq A"r6g :`M:a2G& (R.YPs#c i0$csFNNWY('(_U3G2 Gi!@R59 O}0d;P =Su y  i@\:{g:I1W7 pkvhNs T Pq/h=6I !.n[0R` )aAG n4n0 Ѷ_ !v 0/'wz[; x2۸ Qn{R Q&d{HF@h AЀF0v+QiȻ; Kțʻ;././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/doc/release.txt0000644000000000000000000001573214441703147016366 0ustar00RtMidi - a set of C++ classes that provides a common API for realtime MIDI input/output across Linux (ALSA & JACK), Macintosh OS X (CoreMIDI & JACK), and Windows (Multimedia Library). By Gary P. Scavone, 2003-2021 (with help from many others, especially Stephen Sinclair!) v.5.0.0: (16 November 2021) - see git history for complete list of changes - new Web MIDI API - iOS support - new setBufferSize() function - fixes for WinMM, Jack - added C API test program - now requiring C++11 - build system updates - midiprobe probes all compiled APIs - various build system updates and code efficiencies v.4.0.0: (17 April 2019) - see git history for complete list of changes - updates to test programs to clarify port numbering - new C API wrapper - new functions to get API names - miscellaneous sysex fixes in Jack and ALSA - new setPortName() method (for Jack and ALSA) - new setClientName() method (for ALSA) - various build system updates and code efficiencies v.3.0.0: (31 August 2017) - see git history for complete list of changes - new sendMessage() function that does not use std::vector - various std::string updates, including use of UTF8 for port names - fixes for the MIDI queue - various build system updates and code efficiencies v2.1.1: (11 February 2016) - updates to automake routines - added C API (thanks to Atsushi Eno!) - JACK ringbuffer allocation change - OSX virtual port closing fix - OSX sysex sending fix - moved Windows kernel streaming code to other branch because it is incomplete - miscellaneous small fixes v2.1.0: (30 March 2014) - renamed RtError class to RtMidiError and embedded it in RtMidi.h (and deleted RtError.h) - fix to CoreMIDI implementation to support dynamic port changes - removed global ALSA sequencer objects because they were not thread safe (Martin Koegler) - fix for ALSA timing ignore flag (Devin Anderson) - fix for ALSA incorrect use of snd_seq_create_port() function (Tobias Schlemmer) - fix for international character support in CoreMIDI (Martin Finke) - fix for unicode conversion in WinMM (Dan Wilcox) - added custom error hook that allows the client to capture an RtMidi error outside of the RtMidi code (Pavel Mogilevskiy) - added RtMidi::isPortOpen function (Pavel Mogilevskiy) - updated OS-X sysex sending mechanism to use normal message sending, which fixes a problem where virtual ports didn't receive sysex messages - Windows update to avoid lockups when shutting down while sending/receiving sysex messages (ptarabbia) - OS-X fix to avoid empty messages in callbacks when ignoring sysex messages and split sysexes are received (codepainters) - ALSA openPort fix to better distinguish sender and receiver (Russell Smyth) - Windows Kernel Streaming support removed because it was uncompilable and incomplete v2.0.1: (26 July 2012) - small fixes for problems reported by Chris Arndt (scoping, preprocessor, and include) v2.0.0: (18 June 2012) - revised structure to support multiple simultaneous compiled APIs - revised ALSA client hierarchy so subsequent instances share same client (thanks to Dan Wilcox) - added beta Windows kernel streaming support (thanks to Sebastien Alaiwan) - updates to compile as a shared library or dll - updated license - various memory-leak fixes (thanks to Sebastien Alaiwan and Martin Koegler) - fix for continue sysex problem (thanks to Luc Deschenaux) - removed SGI (IRIX) support v1.0.15: (11 August 2011) - updates for wide character support in Windows - stopped using std::queue and implemented internal MIDI ring buffer (for thread safety ... thanks to Michael Behrman) - removal of the setQueueSizeLimit() function ... queue size limit now an optional arguement to constructor v1.0.14: (17 April 2011) - bug fix to Jack MIDI support (thanks to Alexander Svetalkin and Pedro Lopez-Cabanillas) v1.0.13: (7 April 2011) - updated RtError.h to the same version as in RtAudio - new Jack MIDI support in Linux (thanks to Alexander Svetalkin) v1.0.12: (17 February 2011) - Windows 64-bit pointer fixes (thanks to Ward Kockelkorn) - removed possible exceptions from getPortName() functions - changed sysex sends in OS-X to use MIDISendSysex() function (thanks to Casey Tucker) - bug fixes to time code parsing in OS-X and ALSA (thanks to Greg) - added MSW project file to build as library (into lib/ directory ... thanks to Jason Champion) v1.0.11: (29 January 2010) - added CoreServices/CoreServices.h include for OS-X 10.6 and gcc4.2 compile (thanks to Jon McCormack) - various increment optimizations (thanks to Paul Dean) - fixed incorrectly located snd_seq_close() function in ALSA API (thanks to Pedro Lopez-Cabanillas) - updates to Windows sysex code to better deal with possible delivery problems (thanks to Bastiaan Verreijt) v1.0.10: (3 June 2009) - fix adding timestamp to OS-X sendMessage() function (thanks to John Dey) v1.0.9: (30 April 2009) - added #ifdef AVOID_TIMESTAMPING to conditionally compile support for event timestamping of ALSA sequencer events. This is useful for programs not needing timestamps, saving valuable system resources. - updated functionality in OSX_CORE for getting driver name (thanks to Casey Tucker) v1.0.8: (29 January 2009) - bug fixes for concatenating segmented sysex messages in ALSA (thanks to Christoph Eckert) - update to ALSA sequencer port enumeration (thanks to Pedro Lopez-Cabonillas) - bug fixes for concatenating segmented sysex messages in OS-X (thanks to Emmanuel Litzroth) - added functionality for naming clients (thanks to Pedro Lopez-Cabonillas and Axel Schmidt) - bug fix in Windows when receiving sysex messages if the ignore flag was set (thanks to Pedro Lopez-Cabonillas) v1.0.7: (7 December 2007) - configure and Makefile changes for MinGW - renamed midiinfo.cpp to midiprobe.cpp and updated VC++ project/workspace v1.0.6: (9 March 2006) - bug fix for timestamp problem in ALSA (thanks to Pedro Lopez-Cabanillas) v1.0.5: (18 November 2005) - added optional port name to openVirtualPort() functions - fixed UNICODE problem in Windows getting device names (thanks Eduardo Coutinho!). - fixed bug in Windows with respect to getting Sysex data (thanks Jean-Baptiste Berruchon!) v1.0.4: (14 October 2005) - added check for status byte == 0xF8 if ignoring timing messages - changed pthread attribute to SCHED_OTHER (from SCHED_RR) to avoid thread problem when realtime cababilities are not enabled. - now using ALSA sequencer time stamp information (thanks to Pedro Lopez-Cabanillas) - fixed memory leak in ALSA implementation - now concatenate segmented sysex messages in ALSA v1.0.3: (22 November 2004) - added common pure virtual functions to RtMidi abstract base class v1.0.2: (21 September 2004) - added warning messages to openVirtualPort() functions in Windows and Irix (where it can't be implemented) v1.0.1: (20 September 2004) - changed ALSA preprocessor definition to __LINUX_ALSASEQ__ v1.0.0: (17 September 2004) - first release of new independent class with both input and output functionality ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/m4/ax_cxx_compile_stdcxx.m40000644000000000000000000004564714441703147020631 0ustar00# =========================================================================== # https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html # =========================================================================== # # SYNOPSIS # # AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) # # DESCRIPTION # # Check for baseline language coverage in the compiler for the specified # version of the C++ standard. If necessary, add switches to CXX and # CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) # or '14' (for the C++14 standard). # # The second argument, if specified, indicates whether you insist on an # extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. # -std=c++11). If neither is specified, you get whatever works, with # preference for an extended mode. # # The third argument, if specified 'mandatory' or if left unspecified, # indicates that baseline support for the specified C++ standard is # required and that the macro should error out if no mode with that # support is found. If specified 'optional', then configuration proceeds # regardless, after defining HAVE_CXX${VERSION} if and only if a # supporting mode is found. # # LICENSE # # Copyright (c) 2008 Benjamin Kosnik # Copyright (c) 2012 Zack Weinberg # Copyright (c) 2013 Roy Stogner # Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov # Copyright (c) 2015 Paul Norman # Copyright (c) 2015 Moritz Klammler # Copyright (c) 2016, 2018 Krzesimir Nowak # Copyright (c) 2019 Enji Cooper # # Copying and distribution of this file, with or without modification, are # permitted in any medium without royalty provided the copyright notice # and this notice are preserved. This file is offered as-is, without any # warranty. #serial 11 dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro dnl (serial version number 13). AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], [$1], [14], [ax_cxx_compile_alternatives="14 1y"], [$1], [17], [ax_cxx_compile_alternatives="17 1z"], [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl m4_if([$2], [], [], [$2], [ext], [], [$2], [noext], [], [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], [$3], [optional], [ax_cxx_compile_cxx$1_required=false], [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) AC_LANG_PUSH([C++])dnl ac_success=no m4_if([$2], [noext], [], [dnl if test x$ac_success = xno; then for alternative in ${ax_cxx_compile_alternatives}; do switch="-std=gnu++${alternative}" cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, $cachevar, [ac_save_CXX="$CXX" CXX="$CXX $switch" AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], [eval $cachevar=yes], [eval $cachevar=no]) CXX="$ac_save_CXX"]) if eval test x\$$cachevar = xyes; then CXX="$CXX $switch" if test -n "$CXXCPP" ; then CXXCPP="$CXXCPP $switch" fi ac_success=yes break fi done fi]) m4_if([$2], [ext], [], [dnl if test x$ac_success = xno; then dnl HP's aCC needs +std=c++11 according to: dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf dnl Cray's crayCC needs "-h std=c++11" for alternative in ${ax_cxx_compile_alternatives}; do for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, $cachevar, [ac_save_CXX="$CXX" CXX="$CXX $switch" AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], [eval $cachevar=yes], [eval $cachevar=no]) CXX="$ac_save_CXX"]) if eval test x\$$cachevar = xyes; then CXX="$CXX $switch" if test -n "$CXXCPP" ; then CXXCPP="$CXXCPP $switch" fi ac_success=yes break fi done if test x$ac_success = xyes; then break fi done fi]) AC_LANG_POP([C++]) if test x$ax_cxx_compile_cxx$1_required = xtrue; then if test x$ac_success = xno; then AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) fi fi if test x$ac_success = xno; then HAVE_CXX$1=0 AC_MSG_NOTICE([No compiler with C++$1 support was found]) else HAVE_CXX$1=1 AC_DEFINE(HAVE_CXX$1,1, [define if the compiler supports basic C++$1 syntax]) fi AC_SUBST(HAVE_CXX$1) ]) dnl Test body for checking C++11 support m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 ) dnl Test body for checking C++14 support m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 ) m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 ) dnl Tests for new features in C++11 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ // If the compiler admits that it is not ready for C++11, why torture it? // Hopefully, this will speed up the test. #ifndef __cplusplus #error "This is not a C++ compiler" #elif __cplusplus < 201103L #error "This is not a C++11 compiler" #else namespace cxx11 { namespace test_static_assert { template struct check { static_assert(sizeof(int) <= sizeof(T), "not big enough"); }; } namespace test_final_override { struct Base { virtual ~Base() {} virtual void f() {} }; struct Derived : public Base { virtual ~Derived() override {} virtual void f() override {} }; } namespace test_double_right_angle_brackets { template < typename T > struct check {}; typedef check single_type; typedef check> double_type; typedef check>> triple_type; typedef check>>> quadruple_type; } namespace test_decltype { int f() { int a = 1; decltype(a) b = 2; return a + b; } } namespace test_type_deduction { template < typename T1, typename T2 > struct is_same { static const bool value = false; }; template < typename T > struct is_same { static const bool value = true; }; template < typename T1, typename T2 > auto add(T1 a1, T2 a2) -> decltype(a1 + a2) { return a1 + a2; } int test(const int c, volatile int v) { static_assert(is_same::value == true, ""); static_assert(is_same::value == false, ""); static_assert(is_same::value == false, ""); auto ac = c; auto av = v; auto sumi = ac + av + 'x'; auto sumf = ac + av + 1.0; static_assert(is_same::value == true, ""); static_assert(is_same::value == true, ""); static_assert(is_same::value == true, ""); static_assert(is_same::value == false, ""); static_assert(is_same::value == true, ""); return (sumf > 0.0) ? sumi : add(c, v); } } namespace test_noexcept { int f() { return 0; } int g() noexcept { return 0; } static_assert(noexcept(f()) == false, ""); static_assert(noexcept(g()) == true, ""); } namespace test_constexpr { template < typename CharT > unsigned long constexpr strlen_c_r(const CharT *const s, const unsigned long acc) noexcept { return *s ? strlen_c_r(s + 1, acc + 1) : acc; } template < typename CharT > unsigned long constexpr strlen_c(const CharT *const s) noexcept { return strlen_c_r(s, 0UL); } static_assert(strlen_c("") == 0UL, ""); static_assert(strlen_c("1") == 1UL, ""); static_assert(strlen_c("example") == 7UL, ""); static_assert(strlen_c("another\0example") == 7UL, ""); } namespace test_rvalue_references { template < int N > struct answer { static constexpr int value = N; }; answer<1> f(int&) { return answer<1>(); } answer<2> f(const int&) { return answer<2>(); } answer<3> f(int&&) { return answer<3>(); } void test() { int i = 0; const int c = 0; static_assert(decltype(f(i))::value == 1, ""); static_assert(decltype(f(c))::value == 2, ""); static_assert(decltype(f(0))::value == 3, ""); } } namespace test_uniform_initialization { struct test { static const int zero {}; static const int one {1}; }; static_assert(test::zero == 0, ""); static_assert(test::one == 1, ""); } namespace test_lambdas { void test1() { auto lambda1 = [](){}; auto lambda2 = lambda1; lambda1(); lambda2(); } int test2() { auto a = [](int i, int j){ return i + j; }(1, 2); auto b = []() -> int { return '0'; }(); auto c = [=](){ return a + b; }(); auto d = [&](){ return c; }(); auto e = [a, &b](int x) mutable { const auto identity = [](int y){ return y; }; for (auto i = 0; i < a; ++i) a += b--; return x + identity(a + b); }(0); return a + b + c + d + e; } int test3() { const auto nullary = [](){ return 0; }; const auto unary = [](int x){ return x; }; using nullary_t = decltype(nullary); using unary_t = decltype(unary); const auto higher1st = [](nullary_t f){ return f(); }; const auto higher2nd = [unary](nullary_t f1){ return [unary, f1](unary_t f2){ return f2(unary(f1())); }; }; return higher1st(nullary) + higher2nd(nullary)(unary); } } namespace test_variadic_templates { template struct sum; template struct sum { static constexpr auto value = N0 + sum::value; }; template <> struct sum<> { static constexpr auto value = 0; }; static_assert(sum<>::value == 0, ""); static_assert(sum<1>::value == 1, ""); static_assert(sum<23>::value == 23, ""); static_assert(sum<1, 2>::value == 3, ""); static_assert(sum<5, 5, 11>::value == 21, ""); static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); } // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function // because of this. namespace test_template_alias_sfinae { struct foo {}; template using member = typename T::member_type; template void func(...) {} template void func(member*) {} void test(); void test() { func(0); } } } // namespace cxx11 #endif // __cplusplus >= 201103L ]]) dnl Tests for new features in C++14 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ // If the compiler admits that it is not ready for C++14, why torture it? // Hopefully, this will speed up the test. #ifndef __cplusplus #error "This is not a C++ compiler" #elif __cplusplus < 201402L #error "This is not a C++14 compiler" #else namespace cxx14 { namespace test_polymorphic_lambdas { int test() { const auto lambda = [](auto&&... args){ const auto istiny = [](auto x){ return (sizeof(x) == 1UL) ? 1 : 0; }; const int aretiny[] = { istiny(args)... }; return aretiny[0]; }; return lambda(1, 1L, 1.0f, '1'); } } namespace test_binary_literals { constexpr auto ivii = 0b0000000000101010; static_assert(ivii == 42, "wrong value"); } namespace test_generalized_constexpr { template < typename CharT > constexpr unsigned long strlen_c(const CharT *const s) noexcept { auto length = 0UL; for (auto p = s; *p; ++p) ++length; return length; } static_assert(strlen_c("") == 0UL, ""); static_assert(strlen_c("x") == 1UL, ""); static_assert(strlen_c("test") == 4UL, ""); static_assert(strlen_c("another\0test") == 7UL, ""); } namespace test_lambda_init_capture { int test() { auto x = 0; const auto lambda1 = [a = x](int b){ return a + b; }; const auto lambda2 = [a = lambda1(x)](){ return a; }; return lambda2(); } } namespace test_digit_separators { constexpr auto ten_million = 100'000'000; static_assert(ten_million == 100000000, ""); } namespace test_return_type_deduction { auto f(int& x) { return x; } decltype(auto) g(int& x) { return x; } template < typename T1, typename T2 > struct is_same { static constexpr auto value = false; }; template < typename T > struct is_same { static constexpr auto value = true; }; int test() { auto x = 0; static_assert(is_same::value, ""); static_assert(is_same::value, ""); return x; } } } // namespace cxx14 #endif // __cplusplus >= 201402L ]]) dnl Tests for new features in C++17 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ // If the compiler admits that it is not ready for C++17, why torture it? // Hopefully, this will speed up the test. #ifndef __cplusplus #error "This is not a C++ compiler" #elif __cplusplus < 201703L #error "This is not a C++17 compiler" #else #include #include #include namespace cxx17 { namespace test_constexpr_lambdas { constexpr int foo = [](){return 42;}(); } namespace test::nested_namespace::definitions { } namespace test_fold_expression { template int multiply(Args... args) { return (args * ... * 1); } template bool all(Args... args) { return (args && ...); } } namespace test_extended_static_assert { static_assert (true); } namespace test_auto_brace_init_list { auto foo = {5}; auto bar {5}; static_assert(std::is_same, decltype(foo)>::value); static_assert(std::is_same::value); } namespace test_typename_in_template_template_parameter { template typename X> struct D; } namespace test_fallthrough_nodiscard_maybe_unused_attributes { int f1() { return 42; } [[nodiscard]] int f2() { [[maybe_unused]] auto unused = f1(); switch (f1()) { case 17: f1(); [[fallthrough]]; case 42: f1(); } return f1(); } } namespace test_extended_aggregate_initialization { struct base1 { int b1, b2 = 42; }; struct base2 { base2() { b3 = 42; } int b3; }; struct derived : base1, base2 { int d; }; derived d1 {{1, 2}, {}, 4}; // full initialization derived d2 {{}, {}, 4}; // value-initialized bases } namespace test_general_range_based_for_loop { struct iter { int i; int& operator* () { return i; } const int& operator* () const { return i; } iter& operator++() { ++i; return *this; } }; struct sentinel { int i; }; bool operator== (const iter& i, const sentinel& s) { return i.i == s.i; } bool operator!= (const iter& i, const sentinel& s) { return !(i == s); } struct range { iter begin() const { return {0}; } sentinel end() const { return {5}; } }; void f() { range r {}; for (auto i : r) { [[maybe_unused]] auto v = i; } } } namespace test_lambda_capture_asterisk_this_by_value { struct t { int i; int foo() { return [*this]() { return i; }(); } }; } namespace test_enum_class_construction { enum class byte : unsigned char {}; byte foo {42}; } namespace test_constexpr_if { template int f () { if constexpr(cond) { return 13; } else { return 42; } } } namespace test_selection_statement_with_initializer { int f() { return 13; } int f2() { if (auto i = f(); i > 0) { return 3; } switch (auto i = f(); i + 4) { case 17: return 2; default: return 1; } } } namespace test_template_argument_deduction_for_class_templates { template struct pair { pair (T1 p1, T2 p2) : m1 {p1}, m2 {p2} {} T1 m1; T2 m2; }; void f() { [[maybe_unused]] auto p = pair{13, 42u}; } } namespace test_non_type_auto_template_parameters { template struct B {}; B<5> b1; B<'a'> b2; } namespace test_structured_bindings { int arr[2] = { 1, 2 }; std::pair pr = { 1, 2 }; auto f1() -> int(&)[2] { return arr; } auto f2() -> std::pair& { return pr; } struct S { int x1 : 2; volatile double y1; }; S f3() { return {}; } auto [ x1, y1 ] = f1(); auto& [ xr1, yr1 ] = f1(); auto [ x2, y2 ] = f2(); auto& [ xr2, yr2 ] = f2(); const auto [ x3, y3 ] = f3(); } namespace test_exception_spec_type_system { struct Good {}; struct Bad {}; void g1() noexcept; void g2(); template Bad f(T*, T*); template Good f(T1*, T2*); static_assert (std::is_same_v); } namespace test_inline_variables { template void f(T) {} template inline T g(T) { return T{}; } template<> inline void f<>(int) {} template<> int g<>(int) { return 5; } } } // namespace cxx17 #endif // __cplusplus < 201703L ]]) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/msw/readme0000644000000000000000000000025314441703147015416 0ustar00This directory contains a Visual Studio 2008 project, contributed by Jason Champion, to build rtmidi as a library. The library builds to the \lib directory.././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/msw/rtmidilib.sln0000755000000000000000000000156314441703147016743 0ustar00 Microsoft Visual Studio Solution File, Format Version 10.00 # Visual Studio 2008 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rtmidilib", "rtmidilib.vcproj", "{EBFE5EB3-182A-47A6-922B-52ECF777F6A3}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 Release|Win32 = Release|Win32 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {EBFE5EB3-182A-47A6-922B-52ECF777F6A3}.Debug|Win32.ActiveCfg = Debug|Win32 {EBFE5EB3-182A-47A6-922B-52ECF777F6A3}.Debug|Win32.Build.0 = Debug|Win32 {EBFE5EB3-182A-47A6-922B-52ECF777F6A3}.Release|Win32.ActiveCfg = Release|Win32 {EBFE5EB3-182A-47A6-922B-52ECF777F6A3}.Release|Win32.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/msw/rtmidilib.vcproj0000755000000000000000000000722614441703147017454 0ustar00 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/rtmidi-config.in0000644000000000000000000000060414441703147016513 0ustar00#! /bin/sh if (test "x$#" != "x1") ; then echo "Usage: $0 [--libs | --cxxflags | --cppflags]" exit; fi LIBRARY="@LIBS@" CXXFLAGS="@CXXFLAGS@" CPPFLAGS="@CPPFLAGS@" if (test "x$1" = "x--libs") ; then echo "$LIBRARY -lrtmidi" elif (test "x$1" = "x--cxxflags") ; then echo "$CXXFLAGS" elif (test "x$1" = "x--cppflags") ; then echo "$CPPFLAGS" else echo "Unknown option: $1" fi ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/rtmidi.pc.in0000644000000000000000000000056114441703147015653 0ustar00prefix=@prefix@ exec_prefix=${prefix} libdir=${exec_prefix}/lib includedir=${prefix}/include/rtmidi Name: librtmidi Description: RtMidi - a set of C++ classes that provide a common API for realtime MIDI input/output Version: @PACKAGE_VERSION@ Requires.private: @req@ Libs: -L${libdir} -lrtmidi Libs.private: -lpthread @req_libs@ Cflags: -pthread -I${includedir} @api@ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/rtmidi_c.cpp0000644000000000000000000002375214441703147015737 0ustar00#include #include #include "rtmidi_c.h" #include "RtMidi.h" /* Compile-time assertions that will break if the enums are changed in * the future without synchronizing them properly. If you get (g++) * "error: ‘StaticEnumAssert::StaticEnumAssert() [with bool b = false]’ * is private within this context", it means enums are not aligned. */ template class StaticEnumAssert { private: StaticEnumAssert() {} }; template<> class StaticEnumAssert{ public: StaticEnumAssert() {} }; #define ENUM_EQUAL(x,y) StaticEnumAssert<(int)x==(int)y>() class StaticEnumAssertions { StaticEnumAssertions() { ENUM_EQUAL( RTMIDI_API_UNSPECIFIED, RtMidi::UNSPECIFIED ); ENUM_EQUAL( RTMIDI_API_MACOSX_CORE, RtMidi::MACOSX_CORE ); ENUM_EQUAL( RTMIDI_API_LINUX_ALSA, RtMidi::LINUX_ALSA ); ENUM_EQUAL( RTMIDI_API_UNIX_JACK, RtMidi::UNIX_JACK ); ENUM_EQUAL( RTMIDI_API_WINDOWS_MM, RtMidi::WINDOWS_MM ); ENUM_EQUAL( RTMIDI_API_RTMIDI_DUMMY, RtMidi::RTMIDI_DUMMY ); ENUM_EQUAL( RTMIDI_ERROR_WARNING, RtMidiError::WARNING ); ENUM_EQUAL( RTMIDI_ERROR_DEBUG_WARNING, RtMidiError::DEBUG_WARNING ); ENUM_EQUAL( RTMIDI_ERROR_UNSPECIFIED, RtMidiError::UNSPECIFIED ); ENUM_EQUAL( RTMIDI_ERROR_NO_DEVICES_FOUND, RtMidiError::NO_DEVICES_FOUND ); ENUM_EQUAL( RTMIDI_ERROR_INVALID_DEVICE, RtMidiError::INVALID_DEVICE ); ENUM_EQUAL( RTMIDI_ERROR_MEMORY_ERROR, RtMidiError::MEMORY_ERROR ); ENUM_EQUAL( RTMIDI_ERROR_INVALID_PARAMETER, RtMidiError::INVALID_PARAMETER ); ENUM_EQUAL( RTMIDI_ERROR_INVALID_USE, RtMidiError::INVALID_USE ); ENUM_EQUAL( RTMIDI_ERROR_DRIVER_ERROR, RtMidiError::DRIVER_ERROR ); ENUM_EQUAL( RTMIDI_ERROR_SYSTEM_ERROR, RtMidiError::SYSTEM_ERROR ); ENUM_EQUAL( RTMIDI_ERROR_THREAD_ERROR, RtMidiError::THREAD_ERROR ); }}; class CallbackProxyUserData { public: CallbackProxyUserData (RtMidiCCallback cCallback, void *userData) : c_callback (cCallback), user_data (userData) { } RtMidiCCallback c_callback; void *user_data; }; #ifndef RTMIDI_SOURCE_INCLUDED extern "C" const enum RtMidiApi rtmidi_compiled_apis[]; // casting from RtMidi::Api[] #endif extern "C" const unsigned int rtmidi_num_compiled_apis; /* RtMidi API */ int rtmidi_get_compiled_api (enum RtMidiApi *apis, unsigned int apis_size) { unsigned num = rtmidi_num_compiled_apis; if (apis) { num = (num < apis_size) ? num : apis_size; memcpy(apis, rtmidi_compiled_apis, num * sizeof(enum RtMidiApi)); } return (int)num; } extern "C" const char* rtmidi_api_names[][2]; const char *rtmidi_api_name(enum RtMidiApi api) { if (api < 0 || api >= RTMIDI_API_NUM) return NULL; return rtmidi_api_names[api][0]; } const char *rtmidi_api_display_name(enum RtMidiApi api) { if (api < 0 || api >= RTMIDI_API_NUM) return "Unknown"; return rtmidi_api_names[api][1]; } enum RtMidiApi rtmidi_compiled_api_by_name(const char *name) { RtMidi::Api api = RtMidi::UNSPECIFIED; if (name) { api = RtMidi::getCompiledApiByName(name); } return (enum RtMidiApi)api; } void rtmidi_error (MidiApi *api, enum RtMidiErrorType type, const char* errorString) { std::string msg = errorString; api->error ((RtMidiError::Type) type, msg); } void rtmidi_open_port (RtMidiPtr device, unsigned int portNumber, const char *portName) { std::string name = portName; try { ((RtMidi*) device->ptr)->openPort (portNumber, name); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); } } void rtmidi_open_virtual_port (RtMidiPtr device, const char *portName) { std::string name = portName; try { ((RtMidi*) device->ptr)->openVirtualPort (name); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); } } void rtmidi_close_port (RtMidiPtr device) { try { ((RtMidi*) device->ptr)->closePort (); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); } } unsigned int rtmidi_get_port_count (RtMidiPtr device) { try { return ((RtMidi*) device->ptr)->getPortCount (); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return -1; } } int rtmidi_get_port_name (RtMidiPtr device, unsigned int portNumber, char * bufOut, int * bufLen) { if (bufOut == nullptr && bufLen == nullptr) { return -1; } std::string name; try { name = ((RtMidi*) device->ptr)->getPortName (portNumber); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return -1; } if (bufOut == nullptr) { *bufLen = static_cast(name.size()) + 1; return 0; } return snprintf(bufOut, static_cast(*bufLen), "%s", name.c_str()); } /* RtMidiIn API */ RtMidiInPtr rtmidi_in_create_default () { RtMidiWrapper* wrp = new RtMidiWrapper; try { RtMidiIn* rIn = new RtMidiIn (); wrp->ptr = (void*) rIn; wrp->data = 0; wrp->ok = true; wrp->msg = ""; } catch (const RtMidiError & err) { wrp->ptr = 0; wrp->data = 0; wrp->ok = false; wrp->msg = err.what (); } return wrp; } RtMidiInPtr rtmidi_in_create (enum RtMidiApi api, const char *clientName, unsigned int queueSizeLimit) { std::string name = clientName; RtMidiWrapper* wrp = new RtMidiWrapper; try { RtMidiIn* rIn = new RtMidiIn ((RtMidi::Api) api, name, queueSizeLimit); wrp->ptr = (void*) rIn; wrp->data = 0; wrp->ok = true; wrp->msg = ""; } catch (const RtMidiError & err) { wrp->ptr = 0; wrp->data = 0; wrp->ok = false; wrp->msg = err.what (); } return wrp; } void rtmidi_in_free (RtMidiInPtr device) { if (device->data) delete (CallbackProxyUserData*) device->data; delete (RtMidiIn*) device->ptr; delete device; } enum RtMidiApi rtmidi_in_get_current_api (RtMidiPtr device) { try { return (RtMidiApi) ((RtMidiIn*) device->ptr)->getCurrentApi (); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return RTMIDI_API_UNSPECIFIED; } } static void callback_proxy (double timeStamp, std::vector *message, void *userData) { CallbackProxyUserData* data = reinterpret_cast (userData); data->c_callback (timeStamp, message->data (), message->size (), data->user_data); } void rtmidi_in_set_callback (RtMidiInPtr device, RtMidiCCallback callback, void *userData) { device->data = (void*) new CallbackProxyUserData (callback, userData); try { ((RtMidiIn*) device->ptr)->setCallback (callback_proxy, device->data); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); delete (CallbackProxyUserData*) device->data; device->data = 0; } } void rtmidi_in_cancel_callback (RtMidiInPtr device) { try { ((RtMidiIn*) device->ptr)->cancelCallback (); delete (CallbackProxyUserData*) device->data; device->data = 0; } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); } } void rtmidi_in_ignore_types (RtMidiInPtr device, bool midiSysex, bool midiTime, bool midiSense) { ((RtMidiIn*) device->ptr)->ignoreTypes (midiSysex, midiTime, midiSense); } double rtmidi_in_get_message (RtMidiInPtr device, unsigned char *message, size_t *size) { try { // FIXME: use allocator to achieve efficient buffering std::vector v; double ret = ((RtMidiIn*) device->ptr)->getMessage (&v); if (v.size () > 0 && v.size() <= *size) { memcpy (message, v.data (), (int) v.size ()); } *size = v.size(); return ret; } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return -1; } catch (...) { device->ok = false; device->msg = "Unknown error"; return -1; } } /* RtMidiOut API */ RtMidiOutPtr rtmidi_out_create_default () { RtMidiWrapper* wrp = new RtMidiWrapper; try { RtMidiOut* rOut = new RtMidiOut (); wrp->ptr = (void*) rOut; wrp->data = 0; wrp->ok = true; wrp->msg = ""; } catch (const RtMidiError & err) { wrp->ptr = 0; wrp->data = 0; wrp->ok = false; wrp->msg = err.what (); } return wrp; } RtMidiOutPtr rtmidi_out_create (enum RtMidiApi api, const char *clientName) { RtMidiWrapper* wrp = new RtMidiWrapper; std::string name = clientName; try { RtMidiOut* rOut = new RtMidiOut ((RtMidi::Api) api, name); wrp->ptr = (void*) rOut; wrp->data = 0; wrp->ok = true; wrp->msg = ""; } catch (const RtMidiError & err) { wrp->ptr = 0; wrp->data = 0; wrp->ok = false; wrp->msg = err.what (); } return wrp; } void rtmidi_out_free (RtMidiOutPtr device) { delete (RtMidiOut*) device->ptr; delete device; } enum RtMidiApi rtmidi_out_get_current_api (RtMidiPtr device) { try { return (RtMidiApi) ((RtMidiOut*) device->ptr)->getCurrentApi (); } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return RTMIDI_API_UNSPECIFIED; } } int rtmidi_out_send_message (RtMidiOutPtr device, const unsigned char *message, int length) { try { ((RtMidiOut*) device->ptr)->sendMessage (message, length); return 0; } catch (const RtMidiError & err) { device->ok = false; device->msg = err.what (); return -1; } catch (...) { device->ok = false; device->msg = "Unknown error"; return -1; } } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/rtmidi_c.h0000644000000000000000000002247414441703147015404 0ustar00/************************************************************************/ /*! \defgroup C-interface @{ \brief C interface to realtime MIDI input/output C++ classes. RtMidi offers a C-style interface, principally for use in binding RtMidi to other programming languages. All structs, enums, and functions listed here have direct analogs (and simply call to) items in the C++ RtMidi class and its supporting classes and types */ /************************************************************************/ /*! \file rtmidi_c.h */ #include #include #ifndef RTMIDI_C_H #define RTMIDI_C_H #if defined(RTMIDI_EXPORT) #if defined _WIN32 || defined __CYGWIN__ #define RTMIDIAPI __declspec(dllexport) #else #define RTMIDIAPI __attribute__((visibility("default"))) #endif #else #define RTMIDIAPI //__declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif //! \brief Wraps an RtMidi object for C function return statuses. struct RtMidiWrapper { //! The wrapped RtMidi object. void* ptr; void* data; //! True when the last function call was OK. bool ok; //! If an error occurred (ok != true), set to an error message. const char* msg; }; //! \brief Typedef for a generic RtMidi pointer. typedef struct RtMidiWrapper* RtMidiPtr; //! \brief Typedef for a generic RtMidiIn pointer. typedef struct RtMidiWrapper* RtMidiInPtr; //! \brief Typedef for a generic RtMidiOut pointer. typedef struct RtMidiWrapper* RtMidiOutPtr; //! \brief MIDI API specifier arguments. See \ref RtMidi::Api. enum RtMidiApi { RTMIDI_API_UNSPECIFIED, /*!< Search for a working compiled API. */ RTMIDI_API_MACOSX_CORE, /*!< Macintosh OS-X CoreMIDI API. */ RTMIDI_API_LINUX_ALSA, /*!< The Advanced Linux Sound Architecture API. */ RTMIDI_API_UNIX_JACK, /*!< The Jack Low-Latency MIDI Server API. */ RTMIDI_API_WINDOWS_MM, /*!< The Microsoft Multimedia MIDI API. */ RTMIDI_API_WEB_MIDI_API, /*!< W3C Web MIDI API. */ RTMIDI_API_RTMIDI_DUMMY, /*!< A compilable but non-functional API. */ RTMIDI_API_NUM /*!< Number of values in this enum. */ }; //! \brief Defined RtMidiError types. See \ref RtMidiError::Type. enum RtMidiErrorType { RTMIDI_ERROR_WARNING, /*!< A non-critical error. */ RTMIDI_ERROR_DEBUG_WARNING, /*!< A non-critical error which might be useful for debugging. */ RTMIDI_ERROR_UNSPECIFIED, /*!< The default, unspecified error type. */ RTMIDI_ERROR_NO_DEVICES_FOUND, /*!< No devices found on system. */ RTMIDI_ERROR_INVALID_DEVICE, /*!< An invalid device ID was specified. */ RTMIDI_ERROR_MEMORY_ERROR, /*!< An error occurred during memory allocation. */ RTMIDI_ERROR_INVALID_PARAMETER, /*!< An invalid parameter was specified to a function. */ RTMIDI_ERROR_INVALID_USE, /*!< The function was called incorrectly. */ RTMIDI_ERROR_DRIVER_ERROR, /*!< A system driver error occurred. */ RTMIDI_ERROR_SYSTEM_ERROR, /*!< A system error occurred. */ RTMIDI_ERROR_THREAD_ERROR /*!< A thread error occurred. */ }; /*! \brief The type of a RtMidi callback function. * * \param timeStamp The time at which the message has been received. * \param message The midi message. * \param userData Additional user data for the callback. * * See \ref RtMidiIn::RtMidiCallback. */ typedef void(* RtMidiCCallback) (double timeStamp, const unsigned char* message, size_t messageSize, void *userData); /* RtMidi API */ /*! \brief Determine the available compiled MIDI APIs. * * If the given `apis` parameter is null, returns the number of available APIs. * Otherwise, fill the given apis array with the RtMidi::Api values. * * \param apis An array or a null value. * \param apis_size Number of elements pointed to by apis * \return number of items needed for apis array if apis==NULL, or * number of items written to apis array otherwise. A negative * return value indicates an error. * * See \ref RtMidi::getCompiledApi(). */ RTMIDIAPI int rtmidi_get_compiled_api (enum RtMidiApi *apis, unsigned int apis_size); //! \brief Return the name of a specified compiled MIDI API. //! See \ref RtMidi::getApiName(). RTMIDIAPI const char *rtmidi_api_name(enum RtMidiApi api); //! \brief Return the display name of a specified compiled MIDI API. //! See \ref RtMidi::getApiDisplayName(). RTMIDIAPI const char *rtmidi_api_display_name(enum RtMidiApi api); //! \brief Return the compiled MIDI API having the given name. //! See \ref RtMidi::getCompiledApiByName(). RTMIDIAPI enum RtMidiApi rtmidi_compiled_api_by_name(const char *name); //! \internal Report an error. RTMIDIAPI void rtmidi_error (enum RtMidiErrorType type, const char* errorString); /*! \brief Open a MIDI port. * * \param port Must be greater than 0 * \param portName Name for the application port. * * See RtMidi::openPort(). */ RTMIDIAPI void rtmidi_open_port (RtMidiPtr device, unsigned int portNumber, const char *portName); /*! \brief Creates a virtual MIDI port to which other software applications can * connect. * * \param portName Name for the application port. * * See RtMidi::openVirtualPort(). */ RTMIDIAPI void rtmidi_open_virtual_port (RtMidiPtr device, const char *portName); /*! \brief Close a MIDI connection. * See RtMidi::closePort(). */ RTMIDIAPI void rtmidi_close_port (RtMidiPtr device); /*! \brief Return the number of available MIDI ports. * See RtMidi::getPortCount(). */ RTMIDIAPI unsigned int rtmidi_get_port_count (RtMidiPtr device); /*! \brief Access a string identifier for the specified MIDI input port number. * * To prevent memory leaks a char buffer must be passed to this function. * NULL can be passed as bufOut parameter, and that will write the required buffer length in the bufLen. * * See RtMidi::getPortName(). */ RTMIDIAPI int rtmidi_get_port_name (RtMidiPtr device, unsigned int portNumber, char * bufOut, int * bufLen); /* RtMidiIn API */ //! \brief Create a default RtMidiInPtr value, with no initialization. RTMIDIAPI RtMidiInPtr rtmidi_in_create_default (void); /*! \brief Create a RtMidiInPtr value, with given api, clientName and queueSizeLimit. * * \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. * * See RtMidiIn::RtMidiIn(). */ RTMIDIAPI RtMidiInPtr rtmidi_in_create (enum RtMidiApi api, const char *clientName, unsigned int queueSizeLimit); //! \brief Free the given RtMidiInPtr. RTMIDIAPI void rtmidi_in_free (RtMidiInPtr device); //! \brief Returns the MIDI API specifier for the given instance of RtMidiIn. //! See \ref RtMidiIn::getCurrentApi(). RTMIDIAPI enum RtMidiApi rtmidi_in_get_current_api (RtMidiPtr device); //! \brief Set a callback function to be invoked for incoming MIDI messages. //! See \ref RtMidiIn::setCallback(). RTMIDIAPI void rtmidi_in_set_callback (RtMidiInPtr device, RtMidiCCallback callback, void *userData); //! \brief Cancel use of the current callback function (if one exists). //! See \ref RtMidiIn::cancelCallback(). RTMIDIAPI void rtmidi_in_cancel_callback (RtMidiInPtr device); //! \brief Specify whether certain MIDI message types should be queued or ignored during input. //! See \ref RtMidiIn::ignoreTypes(). RTMIDIAPI void rtmidi_in_ignore_types (RtMidiInPtr device, bool midiSysex, bool midiTime, bool midiSense); /*! Fill the user-provided array with the data bytes for the next available * MIDI message in the input queue and return the event delta-time in seconds. * * \param message Must point to a char* that is already allocated. * SYSEX messages maximum size being 1024, a statically * allocated array could * be sufficient. * \param size Is used to return the size of the message obtained. * Must be set to the size of \ref message when calling. * * See RtMidiIn::getMessage(). */ RTMIDIAPI double rtmidi_in_get_message (RtMidiInPtr device, unsigned char *message, size_t *size); /* RtMidiOut API */ //! \brief Create a default RtMidiInPtr value, with no initialization. RTMIDIAPI RtMidiOutPtr rtmidi_out_create_default (void); /*! \brief Create a RtMidiOutPtr value, with given and clientName. * * \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. * * See RtMidiOut::RtMidiOut(). */ RTMIDIAPI RtMidiOutPtr rtmidi_out_create (enum RtMidiApi api, const char *clientName); //! \brief Free the given RtMidiOutPtr. RTMIDIAPI void rtmidi_out_free (RtMidiOutPtr device); //! \brief Returns the MIDI API specifier for the given instance of RtMidiOut. //! See \ref RtMidiOut::getCurrentApi(). RTMIDIAPI enum RtMidiApi rtmidi_out_get_current_api (RtMidiPtr device); //! \brief Immediately send a single message out an open MIDI output port. //! See \ref RtMidiOut::sendMessage(). RTMIDIAPI int rtmidi_out_send_message (RtMidiOutPtr device, const unsigned char *message, int length); #ifdef __cplusplus } #endif #endif /*! }@ */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/Debug/.placeholder0000644000000000000000000000000014441703147020071 0ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/Makefile.am0000644000000000000000000000177214441703147016635 0ustar00 noinst_PROGRAMS = midiprobe midiout qmidiin cmidiin sysextest midiclock_in midiclock_out \ apinames testcapi AM_CXXFLAGS = -Wall -I$(top_srcdir) AM_CFLAGS = -Wall -I$(top_srcdir) midiprobe_SOURCES = midiprobe.cpp midiprobe_LDADD = $(top_builddir)/librtmidi.la midiout_SOURCES = midiout.cpp midiout_LDADD = $(top_builddir)/librtmidi.la qmidiin_SOURCES = qmidiin.cpp qmidiin_LDADD = $(top_builddir)/librtmidi.la cmidiin_SOURCES = cmidiin.cpp cmidiin_LDADD = $(top_builddir)/librtmidi.la sysextest_SOURCES = sysextest.cpp sysextest_LDADD = $(top_builddir)/librtmidi.la midiclock_in_SOURCES = midiclock.cpp midiclock_in_LDADD = $(top_builddir)/librtmidi.la midiclock_out_SOURCES = midiclock.cpp midiclock_out_LDADD = $(top_builddir)/librtmidi.la apinames_SOURCES = apinames.cpp apinames_LDADD = $(top_builddir)/librtmidi.la testcapi_SOURCES = testcapi.c testcapi_LDADD = $(top_builddir)/librtmidi.la EXTRA_DIST = cmidiin.dsp midiout.dsp midiprobe.dsp qmidiin.dsp \ sysextest.dsp RtMidi.dsw TESTS = apinames ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/Release/.placeholder0000644000000000000000000000000014441703147020423 0ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/RtMidi.dsw0000644000000000000000000000243714441703147016507 0ustar00Microsoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "cmidiin"=".\cmidiin.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "midiout"=".\midiout.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "midiprobe"=".\midiprobe.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "qmidiin"=".\qmidiin.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "sysextest"=".\sysextest.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/apinames.cpp0000644000000000000000000001224414441703147017076 0ustar00/******************************************/ /* apinames.cpp by Jean Pierre Cimalando, 2018. This program tests parts of RtMidi related to API names, the conversion from name to API and vice-versa. */ /******************************************/ #include "RtMidi.h" #include #include #include int test_cpp() { std::vector apis; RtMidi::getCompiledApi( apis ); // ensure the known APIs return valid names std::cout << "API names by identifier (C++):\n"; for ( size_t i = 0; i < apis.size() ; ++i ) { const std::string name = RtMidi::getApiName(apis[i]); if (name.empty()) { std::cout << "Invalid name for API " << (int)apis[i] << "\n"; exit(1); } const std::string displayName = RtMidi::getApiDisplayName(apis[i]); if (displayName.empty()) { std::cout << "Invalid display name for API " << (int)apis[i] << "\n"; exit(1); } std::cout << "* " << (int)apis[i] << " '" << name << "': '" << displayName << "'\n"; } // ensure unknown APIs return the empty string { const std::string name = RtMidi::getApiName((RtMidi::Api)-1); if (!name.empty()) { std::cout << "Bad string for invalid API '" << name << "'\n"; exit(1); } const std::string displayName = RtMidi::getApiDisplayName((RtMidi::Api)-1); if (displayName!="Unknown") { std::cout << "Bad display string for invalid API '" << displayName << "'\n"; exit(1); } } // try getting API identifier by name std::cout << "API identifiers by name (C++):\n"; for ( size_t i = 0; i < apis.size() ; ++i ) { std::string name = RtMidi::getApiName(apis[i]); if ( RtMidi::getCompiledApiByName(name) != apis[i] ) { std::cout << "Bad identifier for API '" << name << "'\n"; exit( 1 ); } std::cout << "* '" << name << "': " << (int)apis[i] << "\n"; for ( size_t j = 0; j < name.size(); ++j ) name[j] = (j & 1) ? toupper(name[j]) : tolower(name[j]); RtMidi::Api api = RtMidi::getCompiledApiByName(name); if ( api != RtMidi::UNSPECIFIED ) { std::cout << "Identifier " << (int)api << " for invalid API '" << name << "'\n"; exit( 1 ); } } // try getting an API identifier by unknown name { RtMidi::Api api; api = RtMidi::getCompiledApiByName(""); if ( api != RtMidi::UNSPECIFIED ) { std::cout << "Bad identifier for unknown API name\n"; exit( 1 ); } } return 0; } #include "rtmidi_c.h" int test_c() { unsigned api_count = rtmidi_get_compiled_api(NULL, 0); std::vector apis(api_count); rtmidi_get_compiled_api(apis.data(), api_count); // ensure the known APIs return valid names std::cout << "API names by identifier (C):\n"; for ( size_t i = 0; i < api_count; ++i) { const std::string name = rtmidi_api_name(apis[i]); if (name.empty()) { std::cout << "Invalid name for API " << (int)apis[i] << "\n"; exit(1); } const std::string displayName = rtmidi_api_display_name(apis[i]); if (displayName.empty()) { std::cout << "Invalid display name for API " << (int)apis[i] << "\n"; exit(1); } std::cout << "* " << (int)apis[i] << " '" << name << "': '" << displayName << "'\n"; } // ensure unknown APIs return the empty string { const char *s = rtmidi_api_name((RtMidiApi)-1); const std::string name(s?s:""); if (!name.empty()) { std::cout << "Bad string for invalid API '" << name << "'\n"; exit(1); } s = rtmidi_api_display_name((RtMidiApi)-1); const std::string displayName(s?s:""); if (displayName!="Unknown") { std::cout << "Bad display string for invalid API '" << displayName << "'\n"; exit(1); } } // try getting API identifier by name std::cout << "API identifiers by name (C):\n"; for ( size_t i = 0; i < api_count ; ++i ) { const char *s = rtmidi_api_name(apis[i]); std::string name(s?s:""); if ( rtmidi_compiled_api_by_name(name.c_str()) != apis[i] ) { std::cout << "Bad identifier for API '" << name << "'\n"; exit( 1 ); } std::cout << "* '" << name << "': " << (int)apis[i] << "\n"; for ( size_t j = 0; j < name.size(); ++j ) name[j] = (j & 1) ? toupper(name[j]) : tolower(name[j]); RtMidiApi api = rtmidi_compiled_api_by_name(name.c_str()); if ( api != RTMIDI_API_UNSPECIFIED ) { std::cout << "Identifier " << (int)api << " for invalid API '" << name << "'\n"; exit( 1 ); } } // try getting an API identifier by unknown name { RtMidiApi api; api = rtmidi_compiled_api_by_name(""); if ( api != RTMIDI_API_UNSPECIFIED ) { std::cout << "Bad identifier for unknown API name\n"; exit( 1 ); } } return 0; } int main() { test_cpp(); test_c(); } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/cmidiin.cpp0000644000000000000000000000547114441703147016721 0ustar00//*****************************************// // cmidiin.cpp // by Gary Scavone, 2003-2004. // // Simple program to test MIDI input and // use of a user callback function. // //*****************************************// #include #include #include "RtMidi.h" void usage( void ) { // Error function in case of incorrect command-line // argument specifications. std::cout << "\nuseage: cmidiin \n"; std::cout << " where port = the device to use (first / default = 0).\n\n"; exit( 0 ); } void mycallback( double deltatime, std::vector< unsigned char > *message, void */*userData*/ ) { unsigned int nBytes = message->size(); for ( unsigned int i=0; i 0 ) std::cout << "stamp = " << deltatime << std::endl; } // This function should be embedded in a try/catch block in case of // an exception. It offers the user a choice of MIDI ports to open. // It returns false if there are no ports available. bool chooseMidiPort( RtMidiIn *rtmidi ); int main( int argc, char ** /*argv[]*/ ) { RtMidiIn *midiin = 0; // Minimal command-line check. if ( argc > 2 ) usage(); try { // RtMidiIn constructor midiin = new RtMidiIn(); // Call function to select port. if ( chooseMidiPort( midiin ) == false ) goto cleanup; // Set our callback function. This should be done immediately after // opening the port to avoid having incoming messages written to the // queue instead of sent to the callback function. midiin->setCallback( &mycallback ); // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, false, false ); std::cout << "\nReading MIDI input ... press to quit.\n"; char input; std::cin.get(input); } catch ( RtMidiError &error ) { error.printMessage(); } cleanup: delete midiin; return 0; } bool chooseMidiPort( RtMidiIn *rtmidi ) { std::cout << "\nWould you like to open a virtual input port? [y/N] "; std::string keyHit; std::getline( std::cin, keyHit ); if ( keyHit == "y" ) { rtmidi->openVirtualPort(); return true; } std::string portName; unsigned int i = 0, nPorts = rtmidi->getPortCount(); if ( nPorts == 0 ) { std::cout << "No input ports available!" << std::endl; return false; } if ( nPorts == 1 ) { std::cout << "\nOpening " << rtmidi->getPortName() << std::endl; } else { for ( i=0; igetPortName(i); std::cout << " Input port #" << i << ": " << portName << '\n'; } do { std::cout << "\nChoose a port number: "; std::cin >> i; } while ( i >= nPorts ); std::getline( std::cin, keyHit ); // used to clear out stdin } rtmidi->openPort( i ); return true; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/cmidiin.dsp0000644000000000000000000001034014441703147016714 0ustar00# Microsoft Developer Studio Project File - Name="cmidiin" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=cmidiin - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "cmidiin.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "cmidiin.mak" CFG="cmidiin - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "cmidiin - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "cmidiin - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "cmidiin - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "cmidiin___Win32_Release" # PROP BASE Intermediate_Dir "cmidiin___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I "../" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "cmidiin - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "cmidiin___Win32_Debug" # PROP BASE Intermediate_Dir "cmidiin___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept !ENDIF # Begin Target # Name "cmidiin - Win32 Release" # Name "cmidiin - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\cmidiin.cpp # End Source File # Begin Source File SOURCE=..\RtMidi.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\RtMidi.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/midiclock.cpp0000644000000000000000000001264514441703147017244 0ustar00//*****************************************// // midiclock.cpp // // Simple program to test MIDI clock sync. Run midiclock_in in one // console and midiclock_out in the other, make sure to choose // options that connect the clocks between programs on your platform. // // (C)2016 Refer to README.md in this archive for copyright. // //*****************************************// #include #include #include "RtMidi.h" // Platform-dependent sleep routines. #if defined(WIN32) #include #define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds ) #else // Unix variants #include #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) ) #endif // These functions should be embedded in a try/catch block in case of // an exception. It offers the user a choice of MIDI ports to open. // It returns false if there are no ports available. bool chooseInputPort( RtMidiIn *rtmidi ); bool chooseOutputPort( RtMidiOut *rtmidi ); void mycallback( double deltatime, std::vector< unsigned char > *message, void *user ) { unsigned int *clock_count = reinterpret_cast(user); // Ignore longer messages if (message->size() != 1) return; unsigned int msg = message->at(0); if (msg == 0xFA) std::cout << "START received" << std::endl; if (msg == 0xFB) std::cout << "CONTINUE received" << std::endl; if (msg == 0xFC) std::cout << "STOP received" << std::endl; if (msg == 0xF8) { if (++*clock_count == 24) { double bpm = 60.0 / 24.0 / deltatime; std::cout << "One beat, estimated BPM = " << bpm <setCallback( &mycallback, &clock_count ); // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, false, false ); std::cout << "\nReading MIDI input ... press to quit.\n"; char input; std::cin.get(input); } catch ( RtMidiError &error ) { error.printMessage(); } cleanup: delete midiin; return 0; } int clock_out() { RtMidiOut *midiout = 0; std::vector message; int sleep_ms = 0, k = 0, j = 0; // RtMidiOut constructor try { midiout = new RtMidiOut(); } catch ( RtMidiError &error ) { error.printMessage(); exit( EXIT_FAILURE ); } // Call function to select port. try { if ( chooseOutputPort( midiout ) == false ) goto cleanup; } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } // Period in ms = 100 BPM // 100*24 ticks / 1 minute, so (60*1000) / (100*24) = 25 ms / tick sleep_ms = 25; std::cout << "Generating clock at " << (60.0 / 24.0 / sleep_ms * 1000.0) << " BPM." << std::endl; // Send out a series of MIDI clock messages. // MIDI start message.clear(); message.push_back( 0xFA ); midiout->sendMessage( &message ); std::cout << "MIDI start" << std::endl; for (j=0; j < 8; j++) { if (j > 0) { // MIDI continue message.clear(); message.push_back( 0xFB ); midiout->sendMessage( &message ); std::cout << "MIDI continue" << std::endl; } for (k=0; k < 96; k++) { // MIDI clock message.clear(); message.push_back( 0xF8 ); midiout->sendMessage( &message ); if (k % 24 == 0) std::cout << "MIDI clock (one beat)" << std::endl; SLEEP( sleep_ms ); } // MIDI stop message.clear(); message.push_back( 0xFC ); midiout->sendMessage( &message ); std::cout << "MIDI stop" << std::endl; SLEEP( 500 ); } // MIDI stop message.clear(); message.push_back( 0xFC ); midiout->sendMessage( &message ); std::cout << "MIDI stop" << std::endl; SLEEP( 500 ); std::cout << "Done!" << std::endl; // Clean up cleanup: delete midiout; return 0; } int main( int, const char *argv[] ) { std::string prog(argv[0]); if (prog.find("midiclock_in") != prog.npos) { clock_in(); } else if (prog.find("midiclock_out") != prog.npos) { clock_out(); } else { std::cout << "Don't know what to do as " << prog << std::endl; } return 0; } template bool choosePort( RT *rtmidi, const char *dir ) { std::string portName; unsigned int i = 0, nPorts = rtmidi->getPortCount(); if ( nPorts == 0 ) { std::cout << "No " << dir << " ports available!" << std::endl; return false; } if ( nPorts == 1 ) { std::cout << "\nOpening " << rtmidi->getPortName() << std::endl; } else { for ( i=0; igetPortName(i); std::cout << " " << dir << " port #" << i << ": " << portName << '\n'; } do { std::cout << "\nChoose a port number: "; std::cin >> i; } while ( i >= nPorts ); } std::cout << "\n"; rtmidi->openPort( i ); return true; } bool chooseInputPort( RtMidiIn *rtmidi ) { return choosePort( rtmidi, "input" ); } bool chooseOutputPort( RtMidiOut *rtmidi ) { return choosePort( rtmidi, "output" ); } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/midiout.cpp0000644000000000000000000000611314441703147016751 0ustar00//*****************************************// // midiout.cpp // by Gary Scavone, 2003-2004. // // Simple program to test MIDI output. // //*****************************************// #include #include #include "RtMidi.h" // Platform-dependent sleep routines. #if defined(WIN32) #include #define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds ) #else // Unix variants #include #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) ) #endif // This function should be embedded in a try/catch block in case of // an exception. It offers the user a choice of MIDI ports to open. // It returns false if there are no ports available. bool chooseMidiPort( RtMidiOut *rtmidi ); int main( void ) { RtMidiOut *midiout = 0; std::vector message; // RtMidiOut constructor try { midiout = new RtMidiOut(); } catch ( RtMidiError &error ) { error.printMessage(); exit( EXIT_FAILURE ); } // Call function to select port. try { if ( chooseMidiPort( midiout ) == false ) goto cleanup; } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } // Send out a series of MIDI messages. // Program change: 192, 5 message.push_back( 192 ); message.push_back( 5 ); midiout->sendMessage( &message ); SLEEP( 500 ); message[0] = 0xF1; message[1] = 60; midiout->sendMessage( &message ); // Control Change: 176, 7, 100 (volume) message[0] = 176; message[1] = 7; message.push_back( 100 ); midiout->sendMessage( &message ); // Note On: 144, 64, 90 message[0] = 144; message[1] = 64; message[2] = 90; midiout->sendMessage( &message ); SLEEP( 500 ); // Note Off: 128, 64, 40 message[0] = 128; message[1] = 64; message[2] = 40; midiout->sendMessage( &message ); SLEEP( 500 ); // Control Change: 176, 7, 40 message[0] = 176; message[1] = 7; message[2] = 40; midiout->sendMessage( &message ); SLEEP( 500 ); // Sysex: 240, 67, 4, 3, 2, 247 message[0] = 240; message[1] = 67; message[2] = 4; message.push_back( 3 ); message.push_back( 2 ); message.push_back( 247 ); midiout->sendMessage( &message ); // Clean up cleanup: delete midiout; return 0; } bool chooseMidiPort( RtMidiOut *rtmidi ) { std::cout << "\nWould you like to open a virtual output port? [y/N] "; std::string keyHit; std::getline( std::cin, keyHit ); if ( keyHit == "y" ) { rtmidi->openVirtualPort(); return true; } std::string portName; unsigned int i = 0, nPorts = rtmidi->getPortCount(); if ( nPorts == 0 ) { std::cout << "No output ports available!" << std::endl; return false; } if ( nPorts == 1 ) { std::cout << "\nOpening " << rtmidi->getPortName() << std::endl; } else { for ( i=0; igetPortName(i); std::cout << " Output port #" << i << ": " << portName << '\n'; } do { std::cout << "\nChoose a port number: "; std::cin >> i; } while ( i >= nPorts ); } std::cout << "\n"; rtmidi->openPort( i ); return true; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/midiout.dsp0000644000000000000000000001034014441703147016752 0ustar00# Microsoft Developer Studio Project File - Name="midiout" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=midiout - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "midiout.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "midiout.mak" CFG="midiout - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "midiout - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "midiout - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "midiout - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "midiout___Win32_Release" # PROP BASE Intermediate_Dir "midiout___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I "../" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "midiout - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "midiout___Win32_Debug" # PROP BASE Intermediate_Dir "midiout___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept !ENDIF # Begin Target # Name "midiout - Win32 Release" # Name "midiout - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\midiout.cpp # End Source File # Begin Source File SOURCE=..\RtMidi.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\RtMidi.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/midiprobe.cpp0000644000000000000000000000413214441703147017250 0ustar00// midiprobe.cpp // // Simple program to check MIDI inputs and outputs. // // by Gary Scavone, 2003-2012. #include #include #include #include "RtMidi.h" int main() { // Create an api map. std::map apiMap; apiMap[RtMidi::MACOSX_CORE] = "OS-X CoreMIDI"; apiMap[RtMidi::WINDOWS_MM] = "Windows MultiMedia"; apiMap[RtMidi::UNIX_JACK] = "Jack Client"; apiMap[RtMidi::LINUX_ALSA] = "Linux ALSA"; apiMap[RtMidi::RTMIDI_DUMMY] = "RtMidi Dummy"; std::vector< RtMidi::Api > apis; RtMidi :: getCompiledApi( apis ); std::cout << "\nCompiled APIs:\n"; for ( unsigned int i=0; igetCurrentApi() ] << std::endl; // Check inputs. unsigned int nPorts = midiin->getPortCount(); std::cout << "\nThere are " << nPorts << " MIDI input sources available.\n"; for ( unsigned i=0; igetPortName(i); std::cout << " Input Port #" << i << ": " << portName << '\n'; } // RtMidiOut constructor ... exception possible midiout = new RtMidiOut(apis[i]); std::cout << "\nCurrent output API: " << apiMap[ midiout->getCurrentApi() ] << std::endl; // Check outputs. nPorts = midiout->getPortCount(); std::cout << "\nThere are " << nPorts << " MIDI output ports available.\n"; for ( unsigned i=0; igetPortName(i); std::cout << " Output Port #" << i << ": " << portName << std::endl; } std::cout << std::endl; } catch ( RtMidiError &error ) { error.printMessage(); } delete midiin; delete midiout; } return 0; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/midiprobe.dsp0000644000000000000000000001040414441703147017253 0ustar00# Microsoft Developer Studio Project File - Name="midiprobe" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=midiprobe - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "midiprobe.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "midiprobe.mak" CFG="midiprobe - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "midiprobe - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "midiprobe - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "midiprobe - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "midiprobe___Win32_Release" # PROP BASE Intermediate_Dir "midiprobe___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I "../" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "midiprobe - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "midiprobe___Win32_Debug" # PROP BASE Intermediate_Dir "midiprobe___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept !ENDIF # Begin Target # Name "midiprobe - Win32 Release" # Name "midiprobe - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\midiprobe.cpp # End Source File # Begin Source File SOURCE=..\RtMidi.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\RtMidi.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/qmidiin.cpp0000644000000000000000000000447114441703147016736 0ustar00//*****************************************// // qmidiin.cpp // by Gary Scavone, 2003-2004. // // Simple program to test MIDI input and // retrieval from the queue. // //*****************************************// #include #include #include #include "RtMidi.h" // Platform-dependent sleep routines. #if defined(WIN32) #include #define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds ) #else // Unix variants #include #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) ) #endif bool done; static void finish( int /*ignore*/ ){ done = true; } void usage( void ) { // Error function in case of incorrect command-line // argument specifications. std::cout << "\nusage: qmidiin \n"; std::cout << " where port = the device to use (first / default = 0).\n\n"; exit( 0 ); } int main( int argc, char *argv[] ) { RtMidiIn *midiin = 0; std::vector message; int nBytes, i; double stamp; // Minimal command-line check. if ( argc > 2 ) usage(); // RtMidiIn constructor try { midiin = new RtMidiIn(); } catch ( RtMidiError &error ) { error.printMessage(); exit( EXIT_FAILURE ); } // Check available ports vs. specified. unsigned int port = 0; unsigned int nPorts = midiin->getPortCount(); if ( argc == 2 ) port = (unsigned int) atoi( argv[1] ); if ( port >= nPorts ) { delete midiin; std::cout << "Invalid port specifier!\n"; usage(); } try { midiin->openPort( port ); } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, false, false ); // Install an interrupt handler function. done = false; (void) signal(SIGINT, finish); // Periodically check input queue. std::cout << "Reading MIDI from port " << midiin->getPortName() << " ... quit with Ctrl-C.\n"; while ( !done ) { stamp = midiin->getMessage( &message ); nBytes = message.size(); for ( i=0; i 0 ) std::cout << "stamp = " << stamp << std::endl; // Sleep for 10 milliseconds. SLEEP( 10 ); } // Clean up cleanup: delete midiin; return 0; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/qmidiin.dsp0000644000000000000000000001034014441703147016732 0ustar00# Microsoft Developer Studio Project File - Name="qmidiin" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=qmidiin - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "qmidiin.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "qmidiin.mak" CFG="qmidiin - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "qmidiin - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "qmidiin - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "qmidiin - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "qmidiin___Win32_Release" # PROP BASE Intermediate_Dir "qmidiin___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I "../" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "qmidiin - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "qmidiin___Win32_Debug" # PROP BASE Intermediate_Dir "qmidiin___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept !ENDIF # Begin Target # Name "qmidiin - Win32 Release" # Name "qmidiin - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\qmidiin.cpp # End Source File # Begin Source File SOURCE=..\RtMidi.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\RtMidi.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/sysextest.cpp0000644000000000000000000000752614441703147017363 0ustar00//*****************************************// // sysextest.cpp // by Gary Scavone, 2003-2005. // // Simple program to test MIDI sysex sending and receiving. // //*****************************************// #include #include #include #include "RtMidi.h" void usage( void ) { std::cout << "\nuseage: sysextest N\n"; std::cout << " where N = length of sysex data to send / receive.\n\n"; exit( 0 ); } // Platform-dependent sleep routines. #if defined(WIN32) #include #define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds ) #else // Unix variants #include #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) ) #endif // This function should be embedded in a try/catch block in case of // an exception. It offers the user a choice of MIDI ports to open. // It returns false if there are no ports available. bool chooseMidiPort( RtMidi *rtmidi ); void mycallback( double deltatime, std::vector< unsigned char > *message, void * /*userData*/ ) { unsigned int nBytes = message->size(); for ( unsigned int i=0; i 0 ) std::cout << "# of bytes = " << nBytes << ", stamp = " << deltatime << std::endl; } int main( int argc, char *argv[] ) { RtMidiOut *midiout = 0; RtMidiIn *midiin = 0; std::vector message; unsigned int i, nBytes; // Minimal command-line check. if ( argc != 2 ) usage(); nBytes = (unsigned int) atoi( argv[1] ); // RtMidiOut and RtMidiIn constructors try { midiout = new RtMidiOut(); midiin = new RtMidiIn(); } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } // Don't ignore sysex, timing, or active sensing messages. midiin->ignoreTypes( false, true, true ); try { if ( chooseMidiPort( midiin ) == false ) goto cleanup; if ( chooseMidiPort( midiout ) == false ) goto cleanup; midiin->setCallback( &mycallback ); message.push_back( 0xF6 ); midiout->sendMessage( &message ); SLEEP( 500 ); // pause a little // Create a long sysex message of numbered bytes and send it out ... twice. for ( int n=0; n<2; n++ ) { message.clear(); message.push_back( 240 ); for ( i=0; isendMessage( &message ); SLEEP( 500 ); // pause a little } } catch ( RtMidiError &error ) { error.printMessage(); goto cleanup; } // Clean up cleanup: delete midiout; delete midiin; return 0; } bool chooseMidiPort( RtMidi *rtmidi ) { bool isInput = false; if ( typeid( *rtmidi ) == typeid( RtMidiIn ) ) isInput = true; if ( isInput ) std::cout << "\nWould you like to open a virtual input port? [y/N] "; else std::cout << "\nWould you like to open a virtual output port? [y/N] "; std::string keyHit; std::getline( std::cin, keyHit ); if ( keyHit == "y" ) { rtmidi->openVirtualPort(); return true; } std::string portName; unsigned int i = 0, nPorts = rtmidi->getPortCount(); if ( nPorts == 0 ) { if ( isInput ) std::cout << "No input ports available!" << std::endl; else std::cout << "No output ports available!" << std::endl; return false; } if ( nPorts == 1 ) { std::cout << "\nOpening " << rtmidi->getPortName() << std::endl; } else { for ( i=0; igetPortName(i); if ( isInput ) std::cout << " Input port #" << i << ": " << portName << '\n'; else std::cout << " Output port #" << i << ": " << portName << '\n'; } do { std::cout << "\nChoose a port number: "; std::cin >> i; } while ( i >= nPorts ); } std::cout << std::endl; rtmidi->openPort( i ); return true; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/sysextest.dsp0000644000000000000000000001041014441703147017351 0ustar00# Microsoft Developer Studio Project File - Name="sysextest" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=sysextest - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "sysextest.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "sysextest.mak" CFG="sysextest - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "sysextest - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "sysextest - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "sysextest - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "sysextest___Win32_Release" # PROP BASE Intermediate_Dir "sysextest___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GR /GX /O2 /I "../" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "sysextest - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "sysextest___Win32_Debug" # PROP BASE Intermediate_Dir "sysextest___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GR /GX /ZI /Od /I "../" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "__WINDOWS_MM__" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept !ENDIF # Begin Target # Name "sysextest - Win32 Release" # Name "sysextest - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\RtMidi.cpp # End Source File # Begin Source File SOURCE=.\sysextest.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\RtMidi.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1686603367.0 python_rtmidi-1.5.8/src/rtmidi/tests/testcapi.c0000644000000000000000000000123314441703147016551 0ustar00 #include #include "rtmidi_c.h" /* Test that the C API for RtMidi is working. */ struct RtMidiWrapper *midiin; struct RtMidiWrapper *midiout; int main() { if ((midiin = rtmidi_in_create_default())) { unsigned int ports = rtmidi_get_port_count(midiin); printf("MIDI input ports found: %u\n", ports); rtmidi_close_port(midiin); rtmidi_in_free(midiin); } if ((midiout = rtmidi_out_create_default())) { unsigned int ports = rtmidi_get_port_count(midiout); printf("MIDI output ports found: %u\n", ports); rtmidi_close_port(midiout); rtmidi_out_free(midiout); } return 0; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/tests/test_basic.py0000644000000000000000000000540714526744666015232 0ustar00#!/usr/bin/env python """Basic tests that don't need midi ports.""" import unittest import rtmidi import pytest @pytest.mark.ci class BasicTest(unittest.TestCase): def test_get_api_display_name(self): 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') self.assertEqual(rtmidi.get_api_display_name(rtmidi.API_WEB_MIDI), 'Web MIDI API') 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') self.assertEqual(rtmidi.get_api_name(rtmidi.API_WEB_MIDI), 'web') 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'), (rtmidi.API_WEB_MIDI, 'web'),): 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, str)) self.assertEqual(version, '5.0.0') def test_nondummy_api_present(self): # Make sure at least one actual API has been compiled apilist = rtmidi.get_compiled_api() apiFound = False for api in apilist: if api != rtmidi.API_RTMIDI_DUMMY: apiFound = True self.assertTrue(apiFound) if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/tests/test_ci_wheels.py0000644000000000000000000000161314526744666016106 0ustar00"""Tests for wheels built by CI.""" import sys import pytest import rtmidi @pytest.mark.ci @pytest.mark.skipif(not sys.platform.lower().startswith("linux"), reason="requires Linux OS") def test_linux_supports_alsa(): assert rtmidi.API_LINUX_ALSA in rtmidi.get_compiled_api() @pytest.mark.ci @pytest.mark.skipif(not sys.platform.lower().startswith("linux"), reason="requires Linux OS") def test_linux_supports_jack(): assert rtmidi.API_UNIX_JACK in rtmidi.get_compiled_api() @pytest.mark.ci @pytest.mark.skipif(not sys.platform.lower().startswith("darwin"), reason="requires macOS") def test_macos_supports_coremidi(): assert rtmidi.API_MACOSX_CORE in rtmidi.get_compiled_api() @pytest.mark.ci @pytest.mark.skipif(not sys.platform.lower().startswith("win"), reason="requires Windows OS") def test_windows_supports_winmm(): assert rtmidi.API_WINDOWS_MM in rtmidi.get_compiled_api() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/tests/test_delete.py0000644000000000000000000000463414526744666015414 0ustar00#!/usr/bin/env python """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=1700514230.0 python_rtmidi-1.5.8/tests/test_errorcallback.py0000644000000000000000000000400714526744666016752 0ustar00#!/usr/bin/env python # -*- coding: utf-8 -*- """Tests for the error callback""" import unittest from unittest 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=1700514230.0 python_rtmidi-1.5.8/tests/test_errors.py0000644000000000000000000000434414526744666015464 0ustar00#!/usr/bin/env python """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=1700514230.0 python_rtmidi-1.5.8/tests/test_rtmidi.py0000644000000000000000000001773614526744666015451 0ustar00#!/usr/bin/env python """Unit tests for the rtmidi module.""" import time import unittest import pytest import rtmidi class BaseTests: NOTE_ON = [0x90, 48, 100] NOTE_OFF = [0x80, 48, 16] SYSEX_IDENTITY_REQUEST = [0xF0, 0x7E, 0x7F, 6, 1, 0xF7] 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) event_1 = self.midi_in.get_message() event_2 = self.midi_in.get_message() self.assertTrue(isinstance(event_1, tuple)) self.assertTrue(isinstance(event_2, tuple)) self.assertEqual(event_1[0], self.NOTE_ON) self.assertEqual(event_2[0], self.NOTE_OFF) def test_send_supports_iterator(self): self.set_up_loopback() self.midi_out.send_message(iter(self.NOTE_ON)) time.sleep(self.DELAY) event = self.midi_in.get_message() self.assertTrue(isinstance(event, tuple)) self.assertEqual(event[0], self.NOTE_ON) def test_send_raises_if_message_too_long(self): self.assertRaises(ValueError, self.midi_out.send_message, [1, 2, 3, 4]) def test_send_raises_if_message_empty(self): self.assertRaises(ValueError, self.midi_out.send_message, []) self.assertRaises(ValueError, self.midi_out.send_message, iter([])) def test_send_accepts_sysex(self): self.set_up_loopback() self.midi_in.ignore_types(sysex=False) self.midi_out.send_message(self.SYSEX_IDENTITY_REQUEST) time.sleep(self.DELAY) event = self.midi_in.get_message() self.assertTrue(isinstance(event, tuple)) self.assertEqual(event[0], self.SYSEX_IDENTITY_REQUEST) 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(): @pytest.mark.jack 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=1700514230.0 python_rtmidi-1.5.8/tox.ini0000644000000000000000000000045314526744666012705 0ustar00[tox] envlist = flake8, py38, py39, py310, py311, py312 skip_missing_interpreters = True isolated_build = True [testenv] commands = pytest -v tests deps = -r{toxinidir}/requirements-dev.txt [testenv:flake8] commands = flake8 {toxinidir}/rtmidi {toxinidir}/examples {toxinidir}/tests deps = flake8 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1700514230.0 python_rtmidi-1.5.8/update-docs.sh0000755000000000000000000000053214526744666014137 0ustar00#!/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 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1700516159.7008936 python_rtmidi-1.5.8/PKG-INFO0000644000000000000000000001657514526750500012463 0ustar00Metadata-Version: 2.1 Name: python-rtmidi Version: 1.5.8 Summary: A Python binding for the RtMidi C++ library implemented using Cython. Keywords: MIDI multimedia music rtmidi Author-Email: Christopher Arndt License: Copyright & License =================== python-rtmidi was written by Christopher Arndt, 2012 - 2023. The software is released unter the MIT License: Copyright (c) 2012 - 2023 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. 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.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI Classifier: Topic :: Software Development :: Libraries :: Python Modules Project-URL: Bug tracker, https://github.com/SpotlightKid/python-rtmidi/issues Project-URL: Documentation, https://spotlightkid.github.io/python-rtmidi/ Project-URL: Download, https://pypi.python.org/pypi/python-rtmidi Project-URL: Homepage, https://github.com/SpotlightKid/python-rtmidi Project-URL: Source, https://gitlab.com/SpotlightKid/python-rtmidi/ Requires-Python: >=3.8 Description-Content-Type: text/markdown # Welcome to python-rtmidi! A Python binding for the RtMidi C++ library implemented using Cython. [![Latest version](https://shields.io/pypi/v/python-rtmidi)](https://pypi.org/project/python-rtmidi) ![Project status](https://shields.io/pypi/status/python-rtmidi) [![MIT License](https://shields.io/pypi/l/python-rtmidi)](LICENSE.md) ![Python versions](https://shields.io/pypi/pyversions/python-rtmidi) [![Distribution format](https://shields.io/pypi/format/python-rtmidi)](https://pypi.org/project/python-rtmidi/#files) [![CI status](https://github.com/SpotlightKid/python-rtmidi/actions/workflows/push_to_master.yml/badge.svg)](https://github.com/SpotlightKid/python-rtmidi/actions) # 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.8+). The [documentation] provides installation instructions, a history of changes per release and an API reference. See the file [LICENSE.md] about copyright and usage terms. The source code repository and issue tracker are hosted on GitHub: . ## 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: ```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: 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.md]: https://github.com/SpotlightKid/python-rtmidi/blob/master/LICENSE.md [python-rtmidi]: https://github.com/SpotlightKid/python-rtmidi [tests]: https://github.com/SpotlightKid/python-rtmidi/tree/master/tests [RtMidi]: http://www.music.mcgill.ca/~gary/rtmidi/index.html