chris
/
jacket
1
1
Fork 0
Code Issues Pull Requests Releases Activity

feat: stream-line API and fix minor wrapping errors (#1) 

* Rename types:
   * `ptr` types have no suffix (e.g. `ClientP` -> `Client`)
   * normal object types hyve a `T` suffix, if needed (e.g. `Port` -> `PortT`)
   * Constants also use CamelCase (UPPER_CASE can still be used).
* Make functions returning an error discardable
* Add missing return types for some functions.

Signed-off-by: Christopher Arndt <chris@chrisarndt.de>
This commit is contained in:
Christopher Arndt 2025-01-20 02:16:38 +01:00 committed by GitHub
parent 1fa9a68ee6
commit 3915638e73
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 273 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
README.md
View File

@ -1,17 +1,19 @@
# jacket # jacket
A [Nim] wrapper for the [JACK] client side [C API] aka *libjack*. A [Nim] wrapper for the JACK Audio Connection Kit ([JACK]) client side [C API]
aka **libjack**.
## Project status ## Project status
This software is in *beta status*. This software is in *beta status*.
The majority of JACK client APIs have been wrapped and are functional (see The majority of JACK client API functions have been wrapped and are functional
[examples]), but some APIs (e.g. threading) still need wrapping. Others, like (see[examples]), but some API parts (e.g. threading) still need wrapping.
the server control or the deprecated session API, will probably not be covered Others, like the server control or the deprecated session API, will probably
by these bindings. While this project is in beta stage, symbol names may still not be covered by these bindings. While this project is in beta stage, symbol
be changed and things moved around before the first stable release. names may still be changed and things moved around before the first stable
release.
## Installation ## Installation
@ -19,7 +21,7 @@ be changed and things moved around before the first stable release.
* Clone this repository. * Clone this repository.
* Change into the `jacket` directory. * Change into the `jacket` directory.
* Run [`nimble install`] (or `nimble develop`). * Run [`nimble install`] (or `nimble develop`).
* Run the [examples] with `nim compile --run examples/<example>.nim`. * Build the [examples] with `nimble examples`.
(Some examples need `--threads:on` with Nim < 2.0). (Some examples need `--threads:on` with Nim < 2.0).
@ -27,10 +29,9 @@ be changed and things moved around before the first stable release.
## Usage ## Usage
Here is a very minimal JACK client application, which just passes audio through Here is a very minimal JACK client application, which just passes audio through
from its single input port to its output port. from its single input port to its output port. Any error checking and handling
has been omitted for brevity's sake. See the files in the [examples] directory
Any error checking and handling has been omitted for brevity's sake. See the for more robust example code.
files in the [examples] directory for more robust example code.
```nim ```nim
import std/os import std/os
@ -38,11 +39,11 @@ import system/ansi_c
import jacket import jacket
var var
jackClient: ClientP
status: cint status: cint
exitSignalled: bool = false exitSignalled = false
inpPort, outPort: PortP inpPort, outPort: Port
type JackBufferP = ptr UncheckedArray[DefaultAudioSample]
type SampleBuffer = ptr UncheckedArray[DefaultAudioSample]
proc signalCb(sig: cint) {.noconv.} = proc signalCb(sig: cint) {.noconv.} =
exitSignalled = true exitSignalled = true
@ -51,30 +52,30 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
exitSignalled = true exitSignalled = true
proc processCb(nFrames: NFrames, arg: pointer): cint {.cdecl.} = proc processCb(nFrames: NFrames, arg: pointer): cint {.cdecl.} =
var inpbuf = cast[JackBufferP](portGetBuffer(inpPort, nFrames)) let inpbuf = cast[SampleBuffer](portGetBuffer(inpPort, nFrames))
var outbuf = cast[JackBufferP](portGetBuffer(outPort, nFrames)) let outbuf = cast[SampleBuffer](portGetBuffer(outPort, nFrames))
# copy samples from input to output buffer # copy samples from input to output buffer
for i in 0 ..< nFrames: for i in 0 ..< nFrames:
outbuf[i] = inpbuf[i] outbuf[i] = inpbuf[i]
# Create JACK Client ptr # Create JACK Client ptr
jackClient = clientOpen("passthru", NullOption, status.addr) var jackClient = clientOpen("passthru", NullOption, status.addr)
# Register audio input and output ports # Register audio input and output ports
inpPort = jackClient.portRegister("in_1", JACK_DEFAULT_AUDIO_TYPE, PortIsInput, 0) inpPort = jackClient.portRegister("in_1", JackDefaultAudioType, PortIsInput, 0)
outPort = jackClient.portRegister("out_1", JACK_DEFAULT_AUDIO_TYPE, PortIsOutput, 0) outPort = jackClient.portRegister("out_1", JackDefaultAudioType, PortIsOutput, 0)
# Set JACK callbacks # Set JACK callbacks
jackClient.onShutdown(shutdownCb) jackClient.onShutdown(shutdownCb)
discard jackClient.setProcessCallback(processCb, nil) jackClient.setProcessCallback(processCb, nil)
# Handle POSIX signals # Handle POSIX signals
c_signal(SIGINT, signalCb) c_signal(SIGINT, signalCb)
c_signal(SIGTERM, signalCb) c_signal(SIGTERM, signalCb)
# Activate JACK client ... # Activate JACK client ...
discard jackClient.activate() jackClient.activate()
while not exitSignalled: while not exitSignalled:
sleep(50) sleep(50)
discard jackClient.clientClose() jackClient.clientClose()
``` ```
@ -85,7 +86,7 @@ This software is released under the *MIT License*. See the file
Please note that the JACK client library (libjack), which this project wraps, Please note that the JACK client library (libjack), which this project wraps,
is licensed under the [LGPL-2.1]. This wrapper does not statically or is licensed under the [LGPL-2.1]. This wrapper does not statically or
dynamically link to libjack, but only loads it via the dynamic linker at dynamically link to libjack at build time, but only loads it via `dynlib` at
run-time. run-time.
Software using this wrapper is, in the opinion of its author, not considered a Software using this wrapper is, in the opinion of its author, not considered a

4
examples/jacket_info.nim
View File

@ -5,7 +5,7 @@ var status: cint
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
# Suppress verbose JACK error messages when server is not available by # Suppress verbose JACK error messages when server is not available by
# default. Pass ``lvlAll`` when creating the logger to enable them. # default. Pass ``lvlAll`` when creating the logger to enable them.
debug "JACK error: " & $msg debug "JACK error: " & $msg
@ -26,4 +26,4 @@ echo("DSP load: ", jclient.cpuLoad, "%")
echo("Server time: ", getTime()) echo("Server time: ", getTime())
echo("Client name: ", jclient.getClientName) echo("Client name: ", jclient.getClientName)
discard jclient.clientClose jclient.clientClose()

6
examples/jacket_list_all_properties.nim
View File

@ -3,12 +3,12 @@ import jacket
var var
status: cint status: cint
descs: ptr UncheckedArray[Description] descs: ptr UncheckedArray[DescriptionT]
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
# Suppress verbose JACK error messages when server is not available by # Suppress verbose JACK error messages when server is not available by
# default. Pass ``lvlAll`` when creating the logger to enable them. # default. Pass ``lvlAll`` when creating the logger to enable them.
debug "JACK error: " & $msg debug "JACK error: " & $msg
@ -40,4 +40,4 @@ if numDescs != -1:
else: else:
error "Could not get properties!" error "Could not get properties!"
discard jclient.clientClose jclient.clientClose()

14
examples/jacket_midi_print.nim
View File

@ -2,9 +2,9 @@ import std/[logging, os, strutils]
import signal import signal
import jacket import jacket
var jclient: ClientP var jclient: Client
var event: MidiEvent var event: MidiEventT
var midiPort: PortP var midiPort: Port
var status: cint var status: cint
var exitSignalled: bool = false var exitSignalled: bool = false
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
@ -13,8 +13,8 @@ var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc cleanup() = proc cleanup() =
debug "Cleaning up..." debug "Cleaning up..."
if jclient != nil: if jclient != nil:
discard jclient.deactivate() jclient.deactivate()
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
@ -30,7 +30,7 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
warn "JACK server has shut down." warn "JACK server has shut down."
exitSignalled = true exitSignalled = true
proc printMidiEvent(event: var MidiEvent) = proc printMidiEvent(event: var MidiEventT) =
if event.size <= 3: if event.size <= 3:
for i in 0..<event.size: for i in 0..<event.size:
stdout.write(event.buffer[i].toHex) stdout.write(event.buffer[i].toHex)
@ -74,7 +74,7 @@ proc main() =
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)
# Create output port # Create output port
midiPort = jclient.portRegister("midi_in", JACK_DEFAULT_MIDI_TYPE, PortIsInput, 0) midiPort = jclient.portRegister("midi_in", JackDefaultMidiType, PortIsInput, 0)
# Activate JACK client ... # Activate JACK client ...
if jclient.activate() == 0: if jclient.activate() == 0:

16
examples/jacket_midi_print_ringbuffer.nim
View File

@ -5,10 +5,10 @@ import signal
import jacket import jacket
var var
jclient: ClientP jclient: Client
event: MidiEvent event: MidiEventT
midiPort: PortP midiPort: Port
rb: RingbufferP rb: Ringbuffer
midiEventPrinter: Thread[void] midiEventPrinter: Thread[void]
status: cint status: cint
exitSignalled: bool = false exitSignalled: bool = false
@ -27,7 +27,7 @@ proc cleanup() =
if jclient != nil: if jclient != nil:
debug "Deactivating JACK client..." debug "Deactivating JACK client..."
discard jclient.deactivate() jclient.deactivate()
if midiEventPrinter.running: if midiEventPrinter.running:
debug "Stopping MIDI event printer thread..." debug "Stopping MIDI event printer thread..."
@ -42,7 +42,7 @@ proc cleanup() =
if jclient != nil: if jclient != nil:
debug "Closing JACK client..." debug "Closing JACK client..."
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
debug fmt"Buffer overruns: {overruns}" debug fmt"Buffer overruns: {overruns}"
@ -68,7 +68,7 @@ proc midiEventPrinterProc() {.thread.} =
while true: while true:
while not exitLoop and ringbufferReadSpace(rb) >= 4: while not exitLoop and ringbufferReadSpace(rb) >= 4:
var read = cast[int](ringbufferRead(rb, cast[cstring](recvBuf.addr), 4)) discard ringbufferRead(rb, cast[cstring](recvBuf.addr), 4)
if recvBuf[0] <= 3: if recvBuf[0] <= 3:
for i in 0..<recvBuf[0].int: for i in 0..<recvBuf[0].int:
@ -138,7 +138,7 @@ proc main() =
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)
# Create output port # Create output port
midiPort = jclient.portRegister("midi_in", JACK_DEFAULT_MIDI_TYPE, PortIsInput, 0) midiPort = jclient.portRegister("midi_in", JackDefaultMidiType, PortIsInput, 0)
# Activate JACK client ... # Activate JACK client ...
if jclient.activate() == 0: if jclient.activate() == 0:

20
examples/jacket_midi_print_thread.nim
View File

@ -3,10 +3,9 @@ import signal
import jacket import jacket
var var
jclient: ClientP jclient: Client
event: MidiEvent midiPort: Port
midiPort: PortP midiEventChan: Channel[MidiEventT]
midiEventChan: Channel[MidiEvent]
midiEventPrinter: Thread[void] midiEventPrinter: Thread[void]
status: cint status: cint
exitSignalled: bool = false exitSignalled: bool = false
@ -19,13 +18,13 @@ proc cleanup() =
if jclient != nil: if jclient != nil:
debug "Deactivating JACK client..." debug "Deactivating JACK client..."
discard jclient.deactivate() jclient.deactivate()
if midiEventPrinter.running: if midiEventPrinter.running:
debug "Stopping MIDI event printer thread..." debug "Stopping MIDI event printer thread..."
# Receiving an invalid event causes receiving thread to wake up and # Receiving an invalid event causes receiving thread to wake up and
# break its endless loop # break its endless loop
event.size = 0 let event = MidiEventT(size: 0)
midiEventChan.send(event) midiEventChan.send(event)
midiEventPrinter.joinThread() midiEventPrinter.joinThread()
@ -35,7 +34,7 @@ proc cleanup() =
if jclient != nil: if jclient != nil:
debug "Closing JACK client..." debug "Closing JACK client..."
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
debug "Bye." debug "Bye."
@ -54,10 +53,8 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
exitSignalled = true exitSignalled = true
proc midiEventPrinterProc() = proc midiEventPrinterProc() =
var event: MidiEvent
while true: while true:
event = midiEventChan.recv() let event = midiEventChan.recv()
if event.size == 0: if event.size == 0:
break break
@ -70,6 +67,7 @@ proc midiEventPrinterProc() =
stdout.flushFile() stdout.flushFile()
proc processCb*(nFrames: NFrames, arg: pointer): cint {.cdecl.} = proc processCb*(nFrames: NFrames, arg: pointer): cint {.cdecl.} =
var event: MidiEventT
let inbuf = portGetBuffer(midiPort, nFrames) let inbuf = portGetBuffer(midiPort, nFrames)
let count = midiGetEventCount(inbuf) let count = midiGetEventCount(inbuf)
@ -110,7 +108,7 @@ proc main() =
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)
# Create output port # Create output port
midiPort = jclient.portRegister("midi_in", JACK_DEFAULT_MIDI_TYPE, PortIsInput, 0) midiPort = jclient.portRegister("midi_in", JackDefaultMidiType, PortIsInput, 0)
# Activate JACK client ... # Activate JACK client ...
if jclient.activate() == 0: if jclient.activate() == 0:

18
examples/jacket_midi_print_threading.nim
View File

@ -10,9 +10,9 @@ import signal
import jacket import jacket
var var
jclient: ClientP jclient: Client
midiPort: PortP midiPort: Port
midiEventChan: Chan[MidiEvent] midiEventChan: Chan[MidiEventT]
midiEventPrinter: Thread[void] midiEventPrinter: Thread[void]
status: cint status: cint
exitSignalled: bool = false exitSignalled: bool = false
@ -25,20 +25,20 @@ proc cleanup() =
if jclient != nil: if jclient != nil:
debug "Deactivating JACK client..." debug "Deactivating JACK client..."
discard jclient.deactivate() jclient.deactivate()
if midiEventPrinter.running: if midiEventPrinter.running:
debug "Stopping MIDI event printer thread..." debug "Stopping MIDI event printer thread..."
# Receiving an invalid event causes receiving thread to wake up and # Receiving an invalid event causes receiving thread to wake up and
# break its endless loop # break its endless loop
let event = MidiEvent(size: 0) let event = MidiEventT(size: 0)
discard midiEventChan.trySend(event) discard midiEventChan.trySend(event)
midiEventPrinter.joinThread() midiEventPrinter.joinThread()
if jclient != nil: if jclient != nil:
debug "Closing JACK client..." debug "Closing JACK client..."
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
debug "Bye." debug "Bye."
@ -57,7 +57,7 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
exitSignalled = true exitSignalled = true
proc midiEventPrinterProc() = proc midiEventPrinterProc() =
var event: MidiEvent var event: MidiEventT
while true: while true:
midiEventChan.recv(event) midiEventChan.recv(event)
@ -72,7 +72,7 @@ proc midiEventPrinterProc() =
stdout.flushFile() stdout.flushFile()
proc processCb*(nFrames: NFrames, arg: pointer): cint {.cdecl.} = proc processCb*(nFrames: NFrames, arg: pointer): cint {.cdecl.} =
var event: MidiEvent var event: MidiEventT
let inbuf = portGetBuffer(midiPort, nFrames) let inbuf = portGetBuffer(midiPort, nFrames)
let count = midiGetEventCount(inbuf) let count = midiGetEventCount(inbuf)
@ -101,7 +101,7 @@ proc main() =
# Set up a thread, which receives MIDI events from process callback via a # Set up a thread, which receives MIDI events from process callback via a
# Channel and prints them without danger of blocking the process callback # Channel and prints them without danger of blocking the process callback
midiEventChan = newChan[MidiEvent]() midiEventChan = newChan[MidiEventT]()
createThread(midiEventPrinter, midiEventPrinterProc) createThread(midiEventPrinter, midiEventPrinterProc)
# Register JACK callbacks # Register JACK callbacks

14
examples/jacket_passthru.nim
View File

@ -6,16 +6,16 @@ import signal
import jacket import jacket
var var
jclient: ClientP jclient: Client
status: cint status: cint
exitSignalled: bool = false exitSignalled: bool = false
inpPort, outPort: PortP inpPort, outPort: Port
log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
type JackBufferP = ptr UncheckedArray[DefaultAudioSample] type JackBufferP = ptr UncheckedArray[DefaultAudioSample]
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
# Suppress verbose JACK error messages when server is not available by # Suppress verbose JACK error messages when server is not available by
# default. Compile in non-release mode or pass ``lvlDebug`` or lower # default. Compile in non-release mode or pass ``lvlDebug`` or lower
# when creating the logger above to enable them. # when creating the logger above to enable them.
debug "JACK error: " & $msg debug "JACK error: " & $msg
@ -23,8 +23,8 @@ proc errorCb(msg: cstring) {.cdecl.} =
proc cleanup(sig: cint = 0) = proc cleanup(sig: cint = 0) =
debug "Cleaning up..." debug "Cleaning up..."
if jclient != nil: if jclient != nil:
discard jclient.deactivate() jclient.deactivate()
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
proc signalCb(sig: cint) {.noconv.} = proc signalCb(sig: cint) {.noconv.} =
@ -55,8 +55,8 @@ if jclient == nil:
quit QuitFailure quit QuitFailure
# Register audio input and output ports # Register audio input and output ports
inpPort = jclient.portRegister("in_1", JACK_DEFAULT_AUDIO_TYPE, PortIsInput, 0) inpPort = jclient.portRegister("in_1", JackDefaultAudioType, PortIsInput, 0)
outPort = jclient.portRegister("out_1", JACK_DEFAULT_AUDIO_TYPE, PortIsOutput, 0) outPort = jclient.portRegister("out_1", JackDefaultAudioType, PortIsOutput, 0)
# Register JACK callbacks # Register JACK callbacks
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)

14
examples/jacket_port_connect_cb.nim
View File

@ -2,7 +2,7 @@ import std/[logging, os]
import jacket import jacket
import signal import signal
var jclient: ClientP var jclient: Client
var status: cint var status: cint
var exitSignalled: bool = false var exitSignalled: bool = false
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
@ -10,8 +10,8 @@ var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc cleanup(sig: cint = 0) = proc cleanup(sig: cint = 0) =
debug "Cleaning up..." debug "Cleaning up..."
if jclient != nil: if jclient != nil:
discard jclient.deactivate() jclient.deactivate()
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
@ -30,7 +30,7 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
proc portConnected(portA: PortId; portB: PortId; connect: cint; arg: pointer) {.cdecl.} = proc portConnected(portA: PortId; portB: PortId; connect: cint; arg: pointer) {.cdecl.} =
let portAPtr = jclient.portById(portA) let portAPtr = jclient.portById(portA)
let portBPtr = jclient.portById(portB) let portBPtr = jclient.portById(portB)
if portAPtr != nil: if portAPtr != nil:
echo("Port A: ", portName(portAPtr)) echo("Port A: ", portName(portAPtr))
else: else:
@ -40,7 +40,7 @@ proc portConnected(portA: PortId; portB: PortId; connect: cint; arg: pointer) {.
echo("Port B: ", portName(portBPtr)) echo("Port B: ", portName(portBPtr))
else: else:
echo "Port B: <unknown>" echo "Port B: <unknown>"
echo("Action: ", if connect > 0: "connect" else: "disconnect") echo("Action: ", if connect > 0: "connect" else: "disconnect")
addHandler(log) addHandler(log)
@ -57,8 +57,8 @@ when defined(windows):
else: else:
setSignalProc(signalCb, SIGABRT, SIGHUP, SIGINT, SIGQUIT, SIGTERM) setSignalProc(signalCb, SIGABRT, SIGHUP, SIGINT, SIGQUIT, SIGTERM)
discard jclient.portRegister("in_1", JACK_DEFAULT_AUDIO_TYPE, PortIsInput, 0) discard jclient.portRegister("in_1", JackDefaultAudioType, PortIsInput, 0)
discard jclient.portRegister("out_1", JACK_DEFAULT_AUDIO_TYPE, PortIsOutput, 0) discard jclient.portRegister("out_1", JackDefaultAudioType, PortIsOutput, 0)
if jclient.setPortConnectCallback(portConnected) != 0: if jclient.setPortConnectCallback(portConnected) != 0:
error "Error: could not set JACK port connection callback." error "Error: could not set JACK port connection callback."

8
examples/jacket_port_register.nim
View File

@ -2,7 +2,7 @@ import std/[logging, os]
import signal import signal
import jacket import jacket
var jclient: ClientP var jclient: Client
var status: cint var status: cint
var exitSignalled: bool = false var exitSignalled: bool = false
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
@ -10,7 +10,7 @@ var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc cleanup(sig: cint = 0) = proc cleanup(sig: cint = 0) =
debug "Cleaning up..." debug "Cleaning up..."
if jclient != nil: if jclient != nil:
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
@ -40,8 +40,8 @@ when defined(windows):
else: else:
setSignalProc(signalCb, SIGABRT, SIGHUP, SIGINT, SIGQUIT, SIGTERM) setSignalProc(signalCb, SIGABRT, SIGHUP, SIGINT, SIGQUIT, SIGTERM)
discard jclient.portRegister("in_1", JACK_DEFAULT_AUDIO_TYPE, PortIsInput, 0) discard jclient.portRegister("in_1", JackDefaultAudioType, PortIsInput, 0)
discard jclient.portRegister("out_1", JACK_DEFAULT_AUDIO_TYPE, PortIsOutput, 0) discard jclient.portRegister("out_1", JackDefaultAudioType, PortIsOutput, 0)
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)

16
examples/jacket_sine.nim
View File

@ -2,8 +2,8 @@ import std/[logging, math, os]
import signal import signal
import jacket import jacket
var jclient: ClientP var jclient: Client
var outPort: PortP var outPort: Port
var status: cint var status: cint
var exitSignalled: bool = false var exitSignalled: bool = false
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
@ -26,7 +26,7 @@ type
proc initSineOsc(sr: float, freq: float): SineOsc = proc initSineOsc(sr: float, freq: float): SineOsc =
let phsInc = twoPi / tableSize let phsInc = twoPi / tableSize
var phase = 0.0 var phase = 0.0
for i in 0 ..< tableSize: for i in 0 ..< tableSize:
result.waveform[i] = sin(phase) result.waveform[i] = sin(phase)
phase += phsInc phase += phsInc
@ -37,15 +37,15 @@ proc initSineOsc(sr: float, freq: float): SineOsc =
proc tick(osc: SineOscP): float = proc tick(osc: SineOscP): float =
result = osc.waveform[int(osc.phase)] result = osc.waveform[int(osc.phase)]
osc.phase += osc.idxInc; osc.phase += osc.idxInc;
if osc.phase >= tableSize: if osc.phase >= tableSize:
osc.phase -= tableSize osc.phase -= tableSize
proc cleanup() = proc cleanup() =
debug "Cleaning up..." debug "Cleaning up..."
if jclient != nil: if jclient != nil:
discard jclient.deactivate() jclient.deactivate()
discard jclient.clientClose() jclient.clientClose()
jclient = nil jclient = nil
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
@ -61,7 +61,7 @@ proc shutdownCb(arg: pointer = nil) {.cdecl.} =
warn "JACK server has shut down." warn "JACK server has shut down."
exitSignalled = true exitSignalled = true
proc processCb(nFrames: NFrames, arg: pointer): cint {.cdecl.} = proc processCb(nFrames: NFrames, arg: pointer): cint {.cdecl.} =
var outbuf = cast[JackBufferP](portGetBuffer(outPort, nFrames)) var outbuf = cast[JackBufferP](portGetBuffer(outPort, nFrames))
let osc = cast[SineOscP](arg) let osc = cast[SineOscP](arg)
@ -101,7 +101,7 @@ if jclient.setProcessCallback(processCb, osc.addr) != 0:
jclient.onShutdown(shutdownCb) jclient.onShutdown(shutdownCb)
# Create output port # Create output port
outPort = jclient.portRegister("out_1", JACK_DEFAULT_AUDIO_TYPE, PortIsOutput, 0) outPort = jclient.portRegister("out_1", JackDefaultAudioType, PortIsOutput, 0)
# Activate JACK client ... # Activate JACK client ...
if jclient.activate() == 0: if jclient.activate() == 0:

8
examples/jacket_transport_query.nim
View File

@ -2,15 +2,15 @@ import std/[logging, strformat]
import jacket import jacket
var var
jclient: ClientP jclient: Client
status: cint status: cint
pos: Position pos: PositionT
transportState: TransportState transportState: TransportState
var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug) var log = newConsoleLogger(when defined(release): lvlInfo else: lvlDebug)
proc errorCb(msg: cstring) {.cdecl.} = proc errorCb(msg: cstring) {.cdecl.} =
# Suppress verbose JACK error messages when server is not available by # Suppress verbose JACK error messages when server is not available by
# default. Pass ``lvlAll`` when creating the logger to enable them. # default. Pass ``lvlAll`` when creating the logger to enable them.
debug "JACK error: " & $msg debug "JACK error: " & $msg
@ -51,4 +51,4 @@ of TransportStarting:
else: else:
echo "Unknown JACK transport state." echo "Unknown JACK transport state."
discard jclient.clientClose jclient.clientClose()

29
jacket.nimble
View File

@ -1,8 +1,8 @@
# Package # Package
version = "0.1.0" version = "0.2.0"
author = "Christopher Arndt" author = "Christopher Arndt"
description = "A Nim wrapper for the JACK client-side C API aka libjack" description = "A Nim wrapper for the JACK Audio Connection Kit client-side C API aka libjack"
license = "MIT" license = "MIT"
srcDir = "src" srcDir = "src"
@ -10,3 +10,28 @@ srcDir = "src"
# Dependencies # Dependencies
requires "nim >= 1.6.0" requires "nim >= 1.6.0"
let examples = @[
"info",
"list_all_properties",
"midi_print",
"midi_print_ringbuffer",
"midi_print_thread",
"midi_print_threading",
"passthru",
"port_connect_cb",
"port_register",
"ringbuffer",
"sine",
"transport_query",
]
task examples, "Build examples (release)":
for example in examples:
echo "Building example 'jacket_" & example & "'..."
selfExec("compile -d:release -d:strip examples/jacket_" & example & ".nim")
task examples_debug, "Build examples (debug)":
for example in examples:
echo "Building example 'jacket_" & example & "' (debug)..."
selfExec("compile examples/jacket_" & example & ".nim")

306
src/jacket.nim
View File

@ -1,6 +1,5 @@
# jacket.nim # jacket.nim
# Possible names/install locations of libjack, according to: # Possible names/install locations of libjack, according to:
# https://github.com/x42/weakjack/blob/master/weak_libjack.c#L108 # https://github.com/x42/weakjack/blob/master/weak_libjack.c#L108
proc getJackLibName: string = proc getJackLibName: string =
@ -19,11 +18,10 @@ proc getJackLibName: string =
# ------------------------------ Constants -------------------------------- # ------------------------------ Constants --------------------------------
const const
JACK_MAX_FRAMES* = (4294967295'i64) JackMaxFrames* = (4294967295'i64)
JACK_LOAD_INIT_LIMIT* = 1024 JackLoadInitLimit* = 1024
JACK_DEFAULT_AUDIO_TYPE* = "32 bit float mono audio" JackDefaultAudioType* = "32 bit float mono audio"
JACK_DEFAULT_MIDI_TYPE* = "8 bit raw midi" JackDefaultMidiType* = "8 bit raw midi"
# ----------------------------- Custom Types ------------------------------ # ----------------------------- Custom Types ------------------------------
@ -37,18 +35,18 @@ type
DefaultAudioSample* = cfloat DefaultAudioSample* = cfloat
type type
Client = distinct object ClientT = distinct object
ClientP* = ptr Client Client* = ptr ClientT
Port = distinct object PortT = distinct object
PortP* = ptr Port Port* = ptr PortT
type type
MidiData* = uint8 MidiData* = uint8
MidiEvent* = object MidiEventT* = object
time*: NFrames time*: NFrames
size*: csize_t size*: csize_t
buffer*: ptr UncheckedArray[MidiData] buffer*: ptr UncheckedArray[MidiData]
MidiEventP* = ptr MidiEvent MidiEvent* = ptr MidiEventT
type type
JackOptions* {.size: sizeof(cint) pure.} = enum JackOptions* {.size: sizeof(cint) pure.} = enum
@ -113,7 +111,7 @@ type
TransportNetStarting = 4 TransportNetStarting = 4
type type
Position* = object PositionT* = object
unique1*: uint64 unique1*: uint64
usecs*: Time usecs*: Time
frameRate*: NFrames frameRate*: NFrames
@ -135,7 +133,7 @@ type
tickDouble*: cdouble tickDouble*: cdouble
padding*: array[5, int32] padding*: array[5, int32]
unique2*: uint64 unique2*: uint64
PositionP* = ptr Position Position* = ptr PositionT
#[ DEPRECATED #[ DEPRECATED
typedef enum { typedef enum {
@ -168,20 +166,20 @@ typedef struct {
]# ]#
const const
JACK_POSITION_MASK* = (PositionBBT.ord or PositionTimecode.ord) JackPositionMask* = (PositionBBT.ord or PositionTimecode.ord)
EXTENDED_TIME_INFO* = true ExtendedTimeInfo* = true
JACK_TICK_DOUBLE* = true JackTickDouble* = true
# Ringbuffer # Ringbuffer
type type
RingbufferData* = object RingbufferDataT* = object
buf*: ptr char buf*: ptr char
len*: csize_t len*: csize_t
RingbufferDataP* = ptr RingbufferData RingbufferData* = ptr RingbufferDataT
Ringbuffer = distinct object RingbufferT = distinct object
RingbufferP* = ptr Ringbuffer Ringbuffer* = ptr RingbufferT
# Metadata # Metadata
@ -196,13 +194,13 @@ type
PropertyChanged, PropertyChanged,
PropertyDeleted PropertyDeleted
Description* = object DescriptionT* = object
subject*: Uuid subject*: Uuid
property_cnt*: uint32 property_cnt*: uint32
properties*: ptr UncheckedArray[Property] properties*: ptr UncheckedArray[Property]
property_size*: uint32 property_size*: uint32
DescriptionP* = ptr Description Description* = ptr DescriptionT
# Callback function types # Callback function types
@ -258,47 +256,47 @@ proc free*(`ptr`: pointer) {.importc: "jack_free".}
# jack_client_t * jack_client_open (char *client_name, # jack_client_t * jack_client_open (char *client_name,
# jack_options_t options, # jack_options_t options,
# jack_status_t *status, ...) # jack_status_t *status, ...)
proc clientOpen*(clientName: cstring; options: cint; status: ptr cint): ClientP {. proc clientOpen*(clientName: cstring; options: cint; status: ptr cint): Client {.
varargs, importc: "jack_client_open".} varargs, importc: "jack_client_open".}
# int jack_client_close (jack_client_t *client) # int jack_client_close (jack_client_t *client)
proc clientClose*(client: ClientP): cint {.importc: "jack_client_close"} proc clientClose*(client: Client): cint {.importc: "jack_client_close", discardable.}
# int jack_client_name_size (void) # int jack_client_name_size (void)
proc clientNameSize*(): cint {.importc: "jack_client_name_size"} proc clientNameSize*(): cint {.importc: "jack_client_name_size"}
# char * jack_get_client_name (jack_client_t *client) # char * jack_get_client_name (jack_client_t *client)
proc getClientName*(client: ClientP): cstring {.importc: "jack_get_client_name".} proc getClientName*(client: Client): cstring {.importc: "jack_get_client_name".}
# char *jack_get_uuid_for_client_name (jack_client_t *client, const char *client_name) # char *jack_get_uuid_for_client_name (jack_client_t *client, const char *client_name)
proc getUuidForClientName*(client: ClientP; clientName: cstring): cstring {. proc getUuidForClientName*(client: Client; clientName: cstring): cstring {.
importc: "jack_get_uuid_for_client_name".} importc: "jack_get_uuid_for_client_name".}
# char *jack_get_client_name_by_uuid (jack_client_t *client, const char *client_uuid) # char *jack_get_client_name_by_uuid (jack_client_t *client, const char *client_uuid)
proc getClientNameByUuid*(client: ClientP; clientUuid: cstring): cstring {. proc getClientNameByUuid*(client: Client; clientUuid: cstring): cstring {.
importc: "jack_get_client_name_by_uuid".} importc: "jack_get_client_name_by_uuid".}
# int jack_activate (jack_client_t *client) # int jack_activate (jack_client_t *client)
proc activate*(client: ClientP): cint {.importc: "jack_activate".} proc activate*(client: Client): cint {.importc: "jack_activate", discardable.}
# int jack_deactivate (jack_client_t *client) # int jack_deactivate (jack_client_t *client)
proc deactivate*(client: ClientP): cint {.importc: "jack_deactivate".} proc deactivate*(client: Client): cint {.importc: "jack_deactivate", discardable.}
# int jack_get_client_pid (const char *name) # int jack_get_client_pid (const char *name)
proc getClientPid*(name: cstring): cint {.importc: "jack_get_client_pid".} proc getClientPid*(name: cstring): cint {.importc: "jack_get_client_pid".}
# FIXME: not implemented yet # FIXME: not implemented yet
# jack_native_thread_t jack_client_thread_id (jack_client_t *client) # jack_native_thread_t jack_client_thread_id (jack_client_t *client)
# proc clientThreadId*(client: ClientP): NativeThread {.importc: "jack_client_thread_id".} # proc clientThreadId*(client: Client): NativeThread {.importc: "jack_client_thread_id".}
# int jack_is_realtime (jack_client_t *client) # int jack_is_realtime (jack_client_t *client)
proc isRealtime*(client: ClientP): cint {.importc: "jack_is_realtime".} proc isRealtime*(client: Client): cint {.importc: "jack_is_realtime".}
# jack_nframes_t jack_cycle_wait (jack_client_t* client) # jack_nframes_t jack_cycle_wait (jack_client_t* client)
proc cycleWait*(client: ClientP): NFrames {.importc: "jack_cycle_wait".} proc cycleWait*(client: Client): NFrames {.importc: "jack_cycle_wait".}
# void jack_cycle_signal (jack_client_t* client, int status) # void jack_cycle_signal (jack_client_t* client, int status)
proc cycleSignal*(client: ClientP; status: cint) {.importc: "jack_cycle_signal".} proc cycleSignal*(client: Client; status: cint) {.importc: "jack_cycle_signal".}
#[ DEPRECATED #[ DEPRECATED
jack_client_t *jack_client_new (const char *client_name) jack_client_t *jack_client_new (const char *client_name)
@ -308,23 +306,23 @@ jack_nframes_t jack_thread_wait (jack_client_t *client, int status)
# --------------------------- Internal Clients ---------------------------- # --------------------------- Internal Clients ----------------------------
# char *jack_get_internal_client_name (jack_client_t *client, jack_intclient_t intclient); # char *jack_get_internal_client_name (jack_client_t *client, jack_intclient_t intclient);
proc getInternalClientName*(client: ClientP; intclient: IntClient): cstring {. proc getInternalClientName*(client: Client; intclient: IntClient): cstring {.
importc: "jack_get_internal_client_name".} importc: "jack_get_internal_client_name".}
# jack_intclient_t jack_internal_client_handle (jack_client_t *client, const char *client_name, # jack_intclient_t jack_internal_client_handle (jack_client_t *client, const char *client_name,
# jack_status_t *status) # jack_status_t *status)
proc internalClientHandle*(client: ClientP; clientName: cstring; status: ptr cint): IntClient {. proc internalClientHandle*(client: Client; clientName: cstring; status: ptr cint): IntClient {.
importc: "jack_internal_client_handle".} importc: "jack_internal_client_handle".}
# jack_intclient_t jack_internal_client_load (jack_client_t *client, const char *client_name, # jack_intclient_t jack_internal_client_load (jack_client_t *client, const char *client_name,
# jack_options_t options, jack_status_t *status, ...) # jack_options_t options, jack_status_t *status, ...)
proc internalClientLoad*(client: ClientP; clientName: cstring; options: cint; status: ptr cint): IntClient {. proc internalClientLoad*(client: Client; clientName: cstring; options: cint; status: ptr cint): IntClient {.
varargs, importc: "jack_internal_client_load".} varargs, importc: "jack_internal_client_load".}
# jack_status_t jack_internal_client_unload (jack_client_t *client, jack_intclient_t intclient) # jack_status_t jack_internal_client_unload (jack_client_t *client, jack_intclient_t intclient)
proc internalClientUnload*(client: ClientP; intclient: IntClient): cint {. proc internalClientUnload*(client: Client; intclient: IntClient): cint {.
importc: "jack_internal_client_unload".} importc: "jack_internal_client_unload", discardable.}
#[ DEPRECATED #[ DEPRECATED
int jack_internal_client_new (const char * client_name, const char *load_name, const char *load_init) int jack_internal_client_new (const char * client_name, const char *load_name, const char *load_init)
@ -334,70 +332,70 @@ void jack_internal_client_close (const char *client_name)
# ------------------------------- Callbacks ------------------------------- # ------------------------------- Callbacks -------------------------------
proc setProcessThread*(client: ClientP; threadCallback: ThreadCallback; arg: pointer = nil): cint {. proc onShutdown*(client: Client; shutdownCallback: ShutdownCallback; arg: pointer = nil) {.
importc: "jack_set_process_thread".}
proc setThreadInitCallback*(client: ClientP; threadInitCallback: ThreadInitCallback; arg: pointer = nil): cint {.
importc: "jack_set_thread_init_callback".}
proc onShutdown*(client: ClientP; shutdownCallback: ShutdownCallback; arg: pointer = nil) {.
importc: "jack_on_shutdown".} importc: "jack_on_shutdown".}
proc onInfoShutdown*(client: ClientP; shutdownCallback: InfoShutdownCallback; arg: pointer = nil) {. proc onInfoShutdown*(client: Client; shutdownCallback: InfoShutdownCallback; arg: pointer = nil) {.
importc: "jack_on_info_shutdown".} importc: "jack_on_info_shutdown".}
proc setProcessCallback*(client: ClientP; processCallback: ProcessCallback; arg: pointer = nil): cint {. proc setProcessThread*(client: Client; threadCallback: ThreadCallback; arg: pointer = nil): cint {.
importc: "jack_set_process_callback".} importc: "jack_set_process_thread", discardable.}
proc setFreewheelCallback*(client: ClientP; freewheelCallback: FreewheelCallback; arg: pointer = nil): cint {. proc setThreadInitCallback*(client: Client; threadInitCallback: ThreadInitCallback; arg: pointer = nil): cint {.
importc: "jack_set_freewheel_callback".} importc: "jack_set_thread_init_callback", discardable.}
proc setBufferSizeCallback*(client: ClientP; bufsizeCallback: BufferSizeCallback; arg: pointer = nil): cint {. proc setProcessCallback*(client: Client; processCallback: ProcessCallback; arg: pointer = nil): cint {.
importc: "jack_set_buffer_size_callback".} importc: "jack_set_process_callback", discardable.}
proc setSampleRateCallback*(client: ClientP; srateCallback: SampleRateCallback; arg: pointer = nil): cint {. proc setFreewheelCallback*(client: Client; freewheelCallback: FreewheelCallback; arg: pointer = nil): cint {.
importc: "jack_set_sample_rate_callback".} importc: "jack_set_freewheel_callback", discardable.}
proc setClientRegistrationCallback*(client: ClientP; registrationCallback: ClientRegistrationCallback; proc setBufferSizeCallback*(client: Client; bufsizeCallback: BufferSizeCallback; arg: pointer = nil): cint {.
importc: "jack_set_buffer_size_callback", discardable.}
proc setSampleRateCallback*(client: Client; srateCallback: SampleRateCallback; arg: pointer = nil): cint {.
importc: "jack_set_sample_rate_callback", discardable.}
proc setClientRegistrationCallback*(client: Client; registrationCallback: ClientRegistrationCallback;
arg: pointer = nil): cint {. arg: pointer = nil): cint {.
importc: "jack_set_client_registration_callback".} importc: "jack_set_client_registration_callback", discardable.}
proc setPortRegistrationCallback*(client: ClientP; registrationCallback: PortRegistrationCallback; proc setPortRegistrationCallback*(client: Client; registrationCallback: PortRegistrationCallback;
arg: pointer = nil): cint {. arg: pointer = nil): cint {.
importc: "jack_set_port_registration_callback".} importc: "jack_set_port_registration_callback", discardable.}
proc setPortConnectCallback*(client: ClientP; connectCallback: PortConnectCallback; arg: pointer = nil): cint {. proc setPortConnectCallback*(client: Client; connectCallback: PortConnectCallback; arg: pointer = nil): cint {.
importc: "jack_set_port_connect_callback".} importc: "jack_set_port_connect_callback", discardable.}
proc setPortRenameCallback*(client: ClientP; renameCallback: PortRenameCallback; arg: pointer = nil): cint {. proc setPortRenameCallback*(client: Client; renameCallback: PortRenameCallback; arg: pointer = nil): cint {.
importc: "jack_set_port_rename_callback".} importc: "jack_set_port_rename_callback", discardable.}
proc setGraphOrderCallback*(client: ClientP; graphCallback: GraphOrderCallback; a3: pointer): cint {. proc setGraphOrderCallback*(client: Client; graphCallback: GraphOrderCallback; arg: pointer = nil): cint {.
importc: "jack_set_graph_order_callback".} importc: "jack_set_graph_order_callback", discardable.}
proc setXrunCallback*(client: ClientP; xrunCallback: XRunCallback; arg: pointer = nil): cint {. proc setXrunCallback*(client: Client; xrunCallback: XRunCallback; arg: pointer = nil): cint {.
importc: "jack_set_xrun_callback".} importc: "jack_set_xrun_callback", discardable.}
proc setLatencyCallback*(client: ClientP; latencyCallback: LatencyCallback; arg: pointer = nil): cint {. proc setLatencyCallback*(client: Client; latencyCallback: LatencyCallback; arg: pointer = nil): cint {.
importc: "jack_set_latency_callback".} importc: "jack_set_latency_callback", discardable.}
# -------------------------- Server Client Control ------------------------ # -------------------------- Server Client Control ------------------------
# int jack_set_freewheel(jack_client_t* client, int onoff) # int jack_set_freewheel(jack_client_t* client, int onoff)
proc setFreewheel*(client: ClientP; onoff: cint): cint {.importc: "jack_set_freewheel".} proc setFreewheel*(client: Client; onoff: cint): cint {.importc: "jack_set_freewheel", discardable.}
# int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes) # int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes)
proc setBufferSize*(client: ClientP; nframes: NFrames): cint {.importc: "jack_set_buffer_size".} proc setBufferSize*(client: Client; nframes: NFrames): cint {.importc: "jack_set_buffer_size", discardable.}
#jack_nframes_t jack_get_sample_rate (jack_client_t *) #jack_nframes_t jack_get_sample_rate (jack_client_t *)
proc getSampleRate*(client: ClientP): NFrames {.importc: "jack_get_sample_rate".} proc getSampleRate*(client: Client): NFrames {.importc: "jack_get_sample_rate"}
# jack_nframes_t jack_get_buffer_size (jack_client_t *) # jack_nframes_t jack_get_buffer_size (jack_client_t *)
proc getBufferSize*(client: ClientP): NFrames {.importc: "jack_get_buffer_size".} proc getBufferSize*(client: Client): NFrames {.importc: "jack_get_buffer_size".}
# float jack_cpu_load (jack_client_t *client) # float jack_cpu_load (jack_client_t *client)
proc cpuLoad*(client: ClientP): cfloat {.importc: "jack_cpu_load".} proc cpuLoad*(client: Client): cfloat {.importc: "jack_cpu_load".}
#[ DEPRECATED #[ DEPRECATED
int jack_engine_takeover_timebase (jack_client_t *) int jack_engine_takeover_timebase (jack_client_t *)
@ -411,82 +409,82 @@ int jack_engine_takeover_timebase (jack_client_t *)
# const char *port_type, # const char *port_type,
# unsigned long flags, # unsigned long flags,
# unsigned long buffer_size) # unsigned long buffer_size)
proc portRegister*(client: ClientP; portName: cstring; portType: cstring; proc portRegister*(client: Client; portName: cstring; portType: cstring;
flags: culong; bufferSize: culong): PortP {.importc: "jack_port_register".} flags: culong; bufferSize: culong): Port {.importc: "jack_port_register".}
# int jack_port_unregister (jack_client_t *client, jack_port_t *port) # int jack_port_unregister (jack_client_t *client, jack_port_t *port)
proc portUnregister*(client: ClientP; port: PortP): cint {.importc: "jack_port_unregister".} proc portUnregister*(client: Client; port: Port): cint {.importc: "jack_port_unregister", discardable.}
# void * jack_port_get_buffer (jack_port_t *port, jack_nframes_t) # void * jack_port_get_buffer (jack_port_t *port, jack_nframes_t)
proc portGetBuffer*(port: PortP; nframes: NFrames): pointer {.importc: "jack_port_get_buffer".} proc portGetBuffer*(port: Port; nframes: NFrames): pointer {.importc: "jack_port_get_buffer".}
# jack_uuid_t jack_port_uuid (const jack_port_t *port) # jack_uuid_t jack_port_uuid (const jack_port_t *port)
proc portUuid*(port: PortP): Uuid {.importc: "jack_port_uuid".} proc portUuid*(port: Port): Uuid {.importc: "jack_port_uuid".}
# const char * jack_port_name (const jack_port_t *port) # const char * jack_port_name (const jack_port_t *port)
proc portName*(port: PortP): cstring {.importc: "jack_port_name".} proc portName*(port: Port): cstring {.importc: "jack_port_name".}
# const char * jack_port_short_name (const jack_port_t *port) # const char * jack_port_short_name (const jack_port_t *port)
proc portShortName*(port: PortP): cstring {.importc: "jack_port_short_name".} proc portShortName*(port: Port): cstring {.importc: "jack_port_short_name".}
# int jack_port_flags (const jack_port_t *port) # int jack_port_flags (const jack_port_t *port)
proc portFlags*(port: PortP): cint {.importc: "jack_port_flags".} proc portFlags*(port: Port): cint {.importc: "jack_port_flags".}
# const char * jack_port_type (const jack_port_t *port) # const char * jack_port_type (const jack_port_t *port)
proc portType*(port: PortP): cstring {.importc: "jack_port_type".} proc portType*(port: Port): cstring {.importc: "jack_port_type".}
# jack_port_type_id_t jack_port_type_id (const jack_port_t *port) # jack_port_type_id_t jack_port_type_id (const jack_port_t *port)
proc portTypeId*(port: PortP): PortTypeId {.importc: "jack_port_type_id".} proc portTypeId*(port: Port): PortTypeId {.importc: "jack_port_type_id".}
# int jack_port_is_mine (const jack_client_t *client, const jack_port_t *port) # int jack_port_is_mine (const jack_client_t *client, const jack_port_t *port)
proc portIsMine*(client: ClientP; port: PortP): cint {. proc portIsMine*(client: Client; port: Port): cint {.
importc: "jack_port_is_mine".} importc: "jack_port_is_mine".}
# int jack_port_connected (const jack_port_t *port) # int jack_port_connected (const jack_port_t *port)
proc portConnected*(port: PortP): cint {.importc: "jack_port_connected".} proc portConnected*(port: Port): cint {.importc: "jack_port_connected".}
# int jack_port_connected_to (const jack_port_t *port, # int jack_port_connected_to (const jack_port_t *port,
# const char *port_name) # const char *port_name)
proc portConnectedTo*(port: PortP; portName: cstring): cint {.importc: "jack_port_connected_to".} proc portConnectedTo*(port: Port; portName: cstring): cint {.importc: "jack_port_connected_to".}
# const char ** jack_port_get_connections (const jack_port_t *port) # const char ** jack_port_get_connections (const jack_port_t *port)
# #
# CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value. # CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value.
proc portGetConnections*(port: PortP): cstringArray {.importc: "jack_port_get_connections".} proc portGetConnections*(port: Port): cstringArray {.importc: "jack_port_get_connections".}
# const char ** jack_port_get_all_connections (const jack_client_t *client, # const char ** jack_port_get_all_connections (const jack_client_t *client,
# const jack_port_t *port) # const jack_port_t *port)
# #
# CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value. # CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value.
proc portGetAllConnections*(client: ClientP; port: PortP): cstringArray {. proc portGetAllConnections*(client: Client; port: Port): cstringArray {.
importc: "jack_port_get_all_connections".} importc: "jack_port_get_all_connections".}
# int jack_port_rename (jack_client_t* client, jack_port_t *port, const char *port_name) # int jack_port_rename (jack_client_t* client, jack_port_t *port, const char *port_name)
proc portRename*(client: ClientP; port: PortP; portName: cstring): cint {.importc: "jack_port_rename".} proc portRename*(client: Client; port: Port; portName: cstring): cint {.importc: "jack_port_rename", discardable.}
# int jack_port_set_alias (jack_port_t *port, const char *alias) # int jack_port_set_alias (jack_port_t *port, const char *alias)
proc portSetAlias*(port: PortP; alias: cstring): cint {.importc: "jack_port_set_alias".} proc portSetAlias*(port: Port; alias: cstring): cint {.importc: "jack_port_set_alias", discardable.}
# int jack_port_unset_alias (jack_port_t *port, const char *alias) # int jack_port_unset_alias (jack_port_t *port, const char *alias)
proc portUnsetAlias*(port: PortP; alias: cstring): cint {.importc: "jack_port_unset_alias".} proc portUnsetAlias*(port: Port; alias: cstring): cint {.importc: "jack_port_unset_alias", discardable.}
# int jack_port_get_aliases (const jack_port_t *port, char* const aliases[2]) # int jack_port_get_aliases (const jack_port_t *port, char* const aliases[2])
proc portGetAliases*(port: PortP; aliases: array[2, cstring]): cint {.importc: "jack_port_get_aliases".} proc portGetAliases*(port: Port; aliases: array[2, cstring]): cint {.importc: "jack_port_get_aliases".}
#int jack_port_request_monitor (jack_port_t *port, int onoff) #int jack_port_request_monitor (jack_port_t *port, int onoff)
proc portRequestMonitor*(port: PortP; onoff: cint): cint {.importc: "jack_port_request_monitor".} proc portRequestMonitor*(port: Port; onoff: cint): cint {.importc: "jack_port_request_monitor", discardable.}
# int jack_port_request_monitor_by_name (jack_client_t *client, # int jack_port_request_monitor_by_name (jack_client_t *client,
# const char *port_name, int onoff) # const char *port_name, int onoff)
proc portRequestMonitorByName*(client: ClientP; portName: cstring; onoff: cint): cint {. proc portRequestMonitorByName*(client: Client; portName: cstring; onoff: cint): cint {.
importc: "jack_port_request_monitor_by_name".} importc: "jack_port_request_monitor_by_name", discardable.}
# int jack_port_ensure_monitor (jack_port_t *port, int onoff) # int jack_port_ensure_monitor (jack_port_t *port, int onoff)
proc portEnsureMonitor*(port: PortP; onoff: cint): cint {. proc portEnsureMonitor*(port: Port; onoff: cint): cint {.
importc: "jack_port_ensure_monitor".} importc: "jack_port_ensure_monitor", discardable.}
# int jack_port_monitoring_input (jack_port_t *port) # int jack_port_monitoring_input (jack_port_t *port)
proc portMonitoringInput*(port: PortP): cint {.importc: "jack_port_monitoring_input".} proc portMonitoringInput*(port: Port): cint {.importc: "jack_port_monitoring_input".}
#[ DEPRECATED #[ DEPRECATED
int jack_port_tie (jack_port_t *src, jack_port_t *dst) int jack_port_tie (jack_port_t *src, jack_port_t *dst)
@ -503,14 +501,14 @@ int jack_port_set_name (jack_port_t *port, const char *port_name)
# unsigned long flags) # unsigned long flags)
# #
# CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value. # CAVEAT: The caller is responsible for calling jack_free() on any non-NULL returned value.
proc getPorts*(client: ClientP; portNamePattern: cstring; proc getPorts*(client: Client; portNamePattern: cstring;
typeNamePattern: cstring; flags: culong): cstringArray {.importc: "jack_get_ports".} typeNamePattern: cstring; flags: culong): cstringArray {.importc: "jack_get_ports".}
# jack_port_t * jack_port_by_name (jack_client_t *client, const char *port_name) # jack_port_t * jack_port_by_name (jack_client_t *client, const char *port_name)
proc portByName*(client: ClientP; portName: cstring): PortP {.importc: "jack_port_by_name".} proc portByName*(client: Client; portName: cstring): Port {.importc: "jack_port_by_name".}
# jack_port_t * jack_port_by_id (jack_client_t *client, jack_port_id_t port_id) # jack_port_t * jack_port_by_id (jack_client_t *client, jack_port_id_t port_id)
proc portById*(client: ClientP; portId: PortId): PortP {.importc: "jack_port_by_id".} proc portById*(client: Client; portId: PortId): Port {.importc: "jack_port_by_id".}
# ------------------------------ Connections ------------------------------ # ------------------------------ Connections ------------------------------
@ -518,15 +516,15 @@ proc portById*(client: ClientP; portId: PortId): PortP {.importc: "jack_port_by_
# int jack_connect (jack_client_t *client, # int jack_connect (jack_client_t *client,
# const char *source_port, # const char *source_port,
# const char *destination_port) # const char *destination_port)
proc connect*(client: ClientP; srcPort: cstring; destPort: cstring): cint {.importc: "jack_connect".} proc connect*(client: Client; srcPort: cstring; destPort: cstring): cint {.importc: "jack_connect", discardable.}
# int jack_disconnect (jack_client_t *client, # int jack_disconnect (jack_client_t *client,
# const char *source_port, # const char *source_port,
# const char *destination_port) # const char *destination_port)
proc disconnect*(client: ClientP; srcPort: cstring; destPort: cstring): cint {.importc: "jack_disconnect".} proc disconnect*(client: Client; srcPort: cstring; destPort: cstring): cint {.importc: "jack_disconnect", discardable.}
# int jack_port_disconnect (jack_client_t *client, jack_port_t *port) # int jack_port_disconnect (jack_client_t *client, jack_port_t *port)
proc portDisconnect*(client: ClientP; port: PortP): cint {.importc: "jack_port_disconnect".} proc portDisconnect*(client: Client; port: Port): cint {.importc: "jack_port_disconnect", discardable.}
# int jack_port_name_size(void) # int jack_port_name_size(void)
proc portNameSize*(): cint {.importc: "jack_port_name_size".} proc portNameSize*(): cint {.importc: "jack_port_name_size".}
@ -535,7 +533,7 @@ proc portNameSize*(): cint {.importc: "jack_port_name_size".}
proc portTypeSize*(): cint {.importc: "jack_port_type_size".} proc portTypeSize*(): cint {.importc: "jack_port_type_size".}
# size_t jack_port_type_get_buffer_size (jack_client_t *client, const char *port_type) # size_t jack_port_type_get_buffer_size (jack_client_t *client, const char *port_type)
proc portTypeGetBufferSize*(client: ClientP; portType: cstring): csize_t {. proc portTypeGetBufferSize*(client: Client; portType: cstring): csize_t {.
importc: "jack_port_type_get_buffer_size".} importc: "jack_port_type_get_buffer_size".}
@ -545,7 +543,7 @@ proc portTypeGetBufferSize*(client: ClientP; portType: cstring): csize_t {.
proc midiGetEventCount*(portBuffer: pointer): NFrames {.importc: "jack_midi_get_event_count".} proc midiGetEventCount*(portBuffer: pointer): NFrames {.importc: "jack_midi_get_event_count".}
# int jack_midi_event_get (jack_midi_event_t *event, void *port_buffer, uint32_t event_index) # int jack_midi_event_get (jack_midi_event_t *event, void *port_buffer, uint32_t event_index)
proc midiEventGet*(event: MidiEventP, portBuffer: pointer, eventIndex: uint32): cint {. proc midiEventGet*(event: MidiEvent, portBuffer: pointer, eventIndex: uint32): cint {.
importc: "jack_midi_event_get".} importc: "jack_midi_event_get".}
# void jack_midi_clear_buffer (void *port_buffer) # void jack_midi_clear_buffer (void *port_buffer)
@ -559,8 +557,8 @@ proc midiEventReserve*(portBuffer: pointer, time: NFrames, dataSize: csize_t): p
importc: "jack_midi_event_reserve".} importc: "jack_midi_event_reserve".}
# int jack_midi_event_write (void *port_buffer, jack_nframes_t time, const jack_midi_data_t *data, size_t data_size) # int jack_midi_event_write (void *port_buffer, jack_nframes_t time, const jack_midi_data_t *data, size_t data_size)
proc midiEventWrite*(portBuffer: pointer, time: NFrames, data: ptr MidiData, dataSize: csize_t): int {. proc midiEventWrite*(portBuffer: pointer, time: NFrames, data: ptr MidiData, dataSize: csize_t): cint {.
importc: "jack_midi_event_write".} importc: "jack_midi_event_write", discardable.}
# uint32_t jack_midi_get_lost_event_count (void *port_buffer) # uint32_t jack_midi_get_lost_event_count (void *port_buffer)
proc midiGetLostEventCount*(portBuffer: pointer): uint32 {.importc: "jack_midi_get_lost_event_count".} proc midiGetLostEventCount*(portBuffer: pointer): uint32 {.importc: "jack_midi_get_lost_event_count".}
@ -569,15 +567,15 @@ proc midiGetLostEventCount*(portBuffer: pointer): uint32 {.importc: "jack_midi_g
# -------------------------------- Latency -------------------------------- # -------------------------------- Latency --------------------------------
# void jack_port_get_latency_range (jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range) # void jack_port_get_latency_range (jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
proc portGetLatencyRange*(port: PortP; mode: LatencyCallbackMode; range: ptr LatencyRange) {. proc portGetLatencyRange*(port: Port; mode: LatencyCallbackMode; range: ptr LatencyRange) {.
importc: "jack_port_get_latency_range".} importc: "jack_port_get_latency_range".}
# void jack_port_set_latency_range (jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range) # void jack_port_set_latency_range (jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
proc portSetLatencyRange*(port: PortP; mode: LatencyCallbackMode; range: ptr LatencyRange) {. proc portSetLatencyRange*(port: Port; mode: LatencyCallbackMode; range: ptr LatencyRange) {.
importc: "jack_port_set_latency_range".} importc: "jack_port_set_latency_range".}
# int jack_recompute_total_latencies (jack_client_t *) # int jack_recompute_total_latencies (jack_client_t *)
proc recomputeTotalLatencies*(client: ClientP): cint {.importc: "jack_recompute_total_latencies".} proc recomputeTotalLatencies*(client: Client): cint {.importc: "jack_recompute_total_latencies", discardable.}
#[ DEPRECATED #[ DEPRECATED
jack_nframes_t jack_port_get_latency (jack_port_t *port) jack_nframes_t jack_port_get_latency (jack_port_t *port)
@ -590,28 +588,28 @@ int jack_recompute_total_latency (jack_client_t *, jack_port_t *port)
# ----------------------------- Time handling ----------------------------- # ----------------------------- Time handling -----------------------------
# jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *) # jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *)
proc framesSinceCycleStart*(client: ClientP): NFrames {.importc: "jack_frames_since_cycle_start".} proc framesSinceCycleStart*(client: Client): NFrames {.importc: "jack_frames_since_cycle_start".}
# jack_nframes_t jack_frame_time (const jack_client_t *) # jack_nframes_t jack_frame_time (const jack_client_t *)
proc frameTime*(client: ClientP): NFrames {.importc: "jack_frame_time".} proc frameTime*(client: Client): NFrames {.importc: "jack_frame_time".}
# jack_nframes_t jack_last_frame_time (const jack_client_t *client) # jack_nframes_t jack_last_frame_time (const jack_client_t *client)
proc lastFrameTime*(client: ClientP): NFrames {.importc: "jack_last_frame_time".} proc lastFrameTime*(client: Client): NFrames {.importc: "jack_last_frame_time".}
# int jack_get_cycle_times(const jack_client_t *client, # int jack_get_cycle_times(const jack_client_t *client,
# jack_nframes_t *current_frames, # jack_nframes_t *current_frames,
# jack_time_t *current_usecs, # jack_time_t *current_usecs,
# jack_time_t *next_usecs, # jack_time_t *next_usecs,
# float *period_usecs) # float *period_usecs)
proc getCycleTimes*(client: ClientP; currentFrames: ptr NFrames; proc getCycleTimes*(client: Client; currentFrames: ptr NFrames;
currentUsecs: ptr Time; nextUsecs: ptr Time; currentUsecs: ptr Time; nextUsecs: ptr Time;
periodUsecs: ptr cfloat): cint {.importc: "jack_get_cycle_times".} periodUsecs: ptr cfloat): cint {.importc: "jack_get_cycle_times".}
# jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t) # jack_time_t jack_frames_to_time(const jack_client_t *client, jack_nframes_t)
proc framesToTime*(client: ClientP; nframes: NFrames): Time {.importc: "jack_frames_to_time".} proc framesToTime*(client: Client; nframes: NFrames): Time {.importc: "jack_frames_to_time".}
# jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t) # jack_nframes_t jack_time_to_frames(const jack_client_t *client, jack_time_t)
proc timeToFrames*(client: ClientP; time: Time): NFrames {.importc: "jack_time_to_frames".} proc timeToFrames*(client: Client; time: Time): NFrames {.importc: "jack_time_to_frames".}
# jack_time_t jack_get_time(void) # jack_time_t jack_get_time(void)
proc getTime*(): Time {.importc: "jack_get_time".} proc getTime*(): Time {.importc: "jack_get_time".}
@ -620,40 +618,40 @@ proc getTime*(): Time {.importc: "jack_get_time".}
# ------------------------------- Transport ------------------------------- # ------------------------------- Transport -------------------------------
# int jack_release_timebase (jack_client_t *client) # int jack_release_timebase (jack_client_t *client)
proc releaseTimebase*(client: ClientP): cint {.importc: "jack_release_timebase".} proc releaseTimebase*(client: Client): cint {.importc: "jack_release_timebase", discardable.}
# int jack_set_sync_callback (jack_client_t *client, JackSyncCallback sync_callback, void *arg) # int jack_set_sync_callback (jack_client_t *client, JackSyncCallback sync_callback, void *arg)
proc setSyncCallback*(client: ClientP; syncCallback: SyncCallback; arg: pointer = nil): cint {. proc setSyncCallback*(client: Client; syncCallback: SyncCallback; arg: pointer = nil): cint {.
importc: "jack_set_sync_callback".} importc: "jack_set_sync_callback", discardable.}
# int jack_set_sync_timeout (jack_client_t *client, jack_time_t timeout) # int jack_set_sync_timeout (jack_client_t *client, jack_time_t timeout)
proc setSyncTimeout*(client: ClientP; timeout: Time): cint {.importc: "jack_set_sync_timeout".} proc setSyncTimeout*(client: Client; timeout: Time): cint {.importc: "jack_set_sync_timeout", discardable.}
# int jack_set_timebase_callback (jack_client_t *client, # int jack_set_timebase_callback (jack_client_t *client,
# int conditional, # int conditional,
# JackTimebaseCallback timebase_callback, # JackTimebaseCallback timebase_callback,
# void *arg) # void *arg)
proc setTimebaseCallback*(client: ClientP; conditional: cint; timebaseCallback: TimebaseCallback; proc setTimebaseCallback*(client: Client; conditional: cint; timebaseCallback: TimebaseCallback;
arg: pointer = nil): cint {. arg: pointer = nil): cint {.
importc: "jack_set_timebase_callback".} importc: "jack_set_timebase_callback", discardable.}
# int jack_transport_locate (jack_client_t *client, jack_nframes_t frame) # int jack_transport_locate (jack_client_t *client, jack_nframes_t frame)
proc transportLocate*(client: ClientP; frame: NFrames): cint {.importc: "jack_transport_locate".} proc transportLocate*(client: Client; frame: NFrames): cint {.importc: "jack_transport_locate", discardable.}
# jack_transport_state_t jack_transport_query (const jack_client_t *client, jack_position_t *pos) # jack_transport_state_t jack_transport_query (const jack_client_t *client, jack_position_t *pos)
proc transportQuery*(client: ClientP; pos: PositionP): TransportState {.importc: "jack_transport_query".} proc transportQuery*(client: Client; pos: Position): TransportState {.importc: "jack_transport_query".}
# jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client) # jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client)
proc getCurrentTransportFrame*(client: ClientP): NFrames {.importc: "jack_get_current_transport_frame".} proc getCurrentTransportFrame*(client: Client): NFrames {.importc: "jack_get_current_transport_frame".}
# int jack_transport_reposition (jack_client_t *client, const jack_position_t *pos) # int jack_transport_reposition (jack_client_t *client, const jack_position_t *pos)
proc transportReposition*(client: ClientP; pos: PositionP): cint {.importc: "jack_transport_reposition".} proc transportReposition*(client: Client; pos: Position): cint {.importc: "jack_transport_reposition".}
# void jack_transport_start (jack_client_t *client) # void jack_transport_start (jack_client_t *client)
proc transportStart*(client: ClientP) {.importc: "jack_transport_start".} proc transportStart*(client: Client) {.importc: "jack_transport_start".}
# void jack_transport_stop (jack_client_t *client) # void jack_transport_stop (jack_client_t *client)
proc transportStop*(client: ClientP) {.importc: "jack_transport_stop".} proc transportStop*(client: Client) {.importc: "jack_transport_stop".}
#[ DEPRECATED #[ DEPRECATED
void jack_get_transport_info (jack_client_t *client, jack_transport_info_t *tinfo) void jack_get_transport_info (jack_client_t *client, jack_transport_info_t *tinfo)
@ -663,79 +661,81 @@ void jack_set_transport_info (jack_client_t *client, jack_transport_info_t *tinf
# ----------------------------- Ringbuffers ------------------------------- # ----------------------------- Ringbuffers -------------------------------
# jack_ringbuffer_t *jack_ringbuffer_create (size_t sz) # jack_ringbuffer_t *jack_ringbuffer_create (size_t sz)
proc ringbufferCreate*(sz: csize_t): RingbufferP {.importc: "jack_ringbuffer_create".} proc ringbufferCreate*(sz: csize_t): Ringbuffer {.importc: "jack_ringbuffer_create".}
# void jack_ringbuffer_free (jack_ringbuffer_t *rb) # void jack_ringbuffer_free (jack_ringbuffer_t *rb)
proc ringbufferFree*(rb: RingbufferP) {.importc: "jack_ringbuffer_free".} proc ringbufferFree*(rb: Ringbuffer) {.importc: "jack_ringbuffer_free".}
# void jack_ringbuffer_get_read_vector (const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec) # void jack_ringbuffer_get_read_vector (const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec)
proc ringbufferGetReadVector*(rb: RingbufferP, vec: var RingbufferDataP) {.importc: "jack_ringbuffer_get_read_vector".} proc ringbufferGetReadVector*(rb: Ringbuffer, vec: var RingbufferData) {.importc: "jack_ringbuffer_get_read_vector".}
# void jack_ringbuffer_get_write_vector (const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec) # void jack_ringbuffer_get_write_vector (const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec)
proc ringbufferGetWriteVector*(rb: RingbufferP, vec: var RingbufferDataP) {.importc: "jack_ringbuffer_get_write_vector".} proc ringbufferGetWriteVector*(rb: Ringbuffer, vec: var RingbufferData) {.importc: "jack_ringbuffer_get_write_vector".}
# size_t jack_ringbuffer_read (jack_ringbuffer_t *rb, char *dest, size_t cnt) # size_t jack_ringbuffer_read (jack_ringbuffer_t *rb, char *dest, size_t cnt)
proc ringbufferRead*(rb: RingbufferP, dest: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_read".} proc ringbufferRead*(rb: Ringbuffer, dest: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_read".}
# size_t jack_ringbuffer_peek (jack_ringbuffer_t *rb, char *dest, size_t cnt) # size_t jack_ringbuffer_peek (jack_ringbuffer_t *rb, char *dest, size_t cnt)
proc ringbufferPeek*(rb: RingbufferP, dest: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_peek".} proc ringbufferPeek*(rb: Ringbuffer, dest: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_peek".}
# void jack_ringbuffer_read_advance (jack_ringbuffer_t *rb, size_t cnt) # void jack_ringbuffer_read_advance (jack_ringbuffer_t *rb, size_t cnt)
proc ringbufferReadAdvance*(rb: RingbufferP, cnt: csize_t) {.importc: "jack_ringbuffer_read_advance".} proc ringbufferReadAdvance*(rb: Ringbuffer, cnt: csize_t) {.importc: "jack_ringbuffer_read_advance".}
# size_t jack_ringbuffer_read_space (const jack_ringbuffer_t *rb) # size_t jack_ringbuffer_read_space (const jack_ringbuffer_t *rb)
proc ringbufferReadSpace*(rb: RingbufferP): csize_t {.importc: "jack_ringbuffer_read_space".} proc ringbufferReadSpace*(rb: Ringbuffer): csize_t {.importc: "jack_ringbuffer_read_space".}
# int jack_ringbuffer_mlock (jack_ringbuffer_t *rb) # int jack_ringbuffer_mlock (jack_ringbuffer_t *rb)
proc ringbufferMlock*(rb: RingbufferP): int {.importc: "jack_ringbuffer_mlock".} proc ringbufferMlock*(rb: Ringbuffer): cint {.importc: "jack_ringbuffer_mlock", discardable.}
# void jack_ringbuffer_reset (jack_ringbuffer_t *rb) # void jack_ringbuffer_reset (jack_ringbuffer_t *rb)
proc ringbufferReset*(rb: RingbufferP) {.importc: "jack_ringbuffer_reset".} proc ringbufferReset*(rb: Ringbuffer) {.importc: "jack_ringbuffer_reset".}
# size_t jack_ringbuffer_write (jack_ringbuffer_t *rb, const char *src, size_t cnt) # size_t jack_ringbuffer_write (jack_ringbuffer_t *rb, const char *src, size_t cnt)
proc ringbufferWrite*(rb: RingbufferP, src: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_write".} proc ringbufferWrite*(rb: Ringbuffer, src: cstring, cnt: csize_t): csize_t {.importc: "jack_ringbuffer_write".}
# void jack_ringbuffer_write_advance (jack_ringbuffer_t *rb, size_t cnt) # void jack_ringbuffer_write_advance (jack_ringbuffer_t *rb, size_t cnt)
proc ringbufferWriteAdvance*(rb: RingbufferP, cnt: csize_t) {.importc: "jack_ringbuffer_write_advance".} proc ringbufferWriteAdvance*(rb: Ringbuffer, cnt: csize_t) {.importc: "jack_ringbuffer_write_advance".}
# size_t jack_ringbuffer_write_space (const jack_ringbuffer_t *rb) # size_t jack_ringbuffer_write_space (const jack_ringbuffer_t *rb)
proc ringbufferWriteSpace*(rb: RingbufferP): csize_t {.importc: "jack_ringbuffer_write_space".} proc ringbufferWriteSpace*(rb: Ringbuffer): csize_t {.importc: "jack_ringbuffer_write_space".}
# ------------------------------- Metadata -------------------------------- # ------------------------------- Metadata --------------------------------
# int jack_set_property (jack_client_t*, jack_uuid_t subject, const char* key, const char* value, const char* type) # int jack_set_property (jack_client_t*, jack_uuid_t subject, const char* key, const char* value, const char* type)
proc setProperty*(client: ClientP, subject: Uuid, key, value, `type`: cstring): cint {.importc: "jack_set_property".} proc setProperty*(client: Client, subject: Uuid, key, value, `type`: cstring): cint {.importc: "jack_set_property", discardable.}
# int jack_get_property (jack_uuid_t subject, const char* key, char** value, char** type) # int jack_get_property (jack_uuid_t subject, const char* key, char** value, char** type)
proc getProperty*(subject: Uuid, key: cstring, value, `type`: ptr cstring): cint {.importc: "jack_get_property".} proc getProperty*(subject: Uuid, key: cstring, value, `type`: ptr cstring): cint {.importc: "jack_get_property", discardable.}
# void jack_free_description (jack_description_t* desc, int free_description_itself) # void jack_free_description (jack_description_t* desc, int free_description_itself)
proc freeDescription*(desc: DescriptionP, freeDescriptionItself: cint) {.importc: "jack_free_description".} proc freeDescription*(desc: Description, freeDescriptionItself: cint) {.importc: "jack_free_description".}
# int jack_get_properties (jack_uuid_t subject, jack_description_t* desc) # int jack_get_properties (jack_uuid_t subject, jack_description_t* desc)
proc getProperties*(subject: Uuid, desc: DescriptionP): cint {.importc: "jack_get_properties".} proc getProperties*(subject: Uuid, desc: Description): cint {.importc: "jack_get_properties", discardable.}
# int jack_get_all_properties (jack_description_t** descs) # int jack_get_all_properties (jack_description_t** descs)
proc getAllProperties*(descs: var ptr UncheckedArray[Description]): cint {.importc: "jack_get_all_properties".} proc getAllProperties*(descs: var ptr UncheckedArray[DescriptionT]): cint {.importc: "jack_get_all_properties", discardable.}
# int jack_remove_property (jack_client_t* client, jack_uuid_t subject, const char* key) # int jack_remove_property (jack_client_t* client, jack_uuid_t subject, const char* key)
proc removeProperty*(client: ClientP, subject: Uuid): cint {.importc: "jack_remove_property".} proc removeProperty*(client: Client, subject: Uuid): cint {.importc: "jack_remove_property", discardable.}
# int jack_remove_properties (jack_client_t* client, jack_uuid_t subject) # int jack_remove_properties (jack_client_t* client, jack_uuid_t subject)
proc removeProperties*(client: ClientP, subject: Uuid): cint {.importc: "jack_remove_properties".} proc removeProperties*(client: Client, subject: Uuid): cint {.importc: "jack_remove_properties", discardable.}
# int jack_remove_all_properties (jack_client_t* client) # int jack_remove_all_properties (jack_client_t* client)
proc removeAllProperties*(client: ClientP): cint {.importc: "jack_remove_all_properties".} proc removeAllProperties*(client: Client): cint {.importc: "jack_remove_all_properties", discardable.}
# int jack_set_property_change_callback (jack_client_t* client, JackPropertyChangeCallback callback, void* arg) # int jack_set_property_change_callback (jack_client_t* client, JackPropertyChangeCallback callback, void* arg)
proc setPropertyChangeCallback*(client: ClientP, callback: PropertyChangeCallback, arg: pointer = nil): cint {. proc setPropertyChangeCallback*(client: Client, callback: PropertyChangeCallback, arg: pointer = nil): cint {.
importc: "jack_set_property_change_callback".} importc: "jack_set_property_change_callback", discardable.}
# ---------------------------- Error handling ----------------------------- # ---------------------------- Error handling -----------------------------
# void jack_set_error_function (void(*)(const char *) func)
proc setErrorFunction*(errorCallback: ErrorCallback) {.importc: "jack_set_error_function".} proc setErrorFunction*(errorCallback: ErrorCallback) {.importc: "jack_set_error_function".}
# void jack_set_info_function (void(*)(const char *) func)
proc setInfoFunction*(infoCallback: InfoCallback) {.importc: "jack_set_info_function".} proc setInfoFunction*(infoCallback: InfoCallback) {.importc: "jack_set_info_function".}
{.pop.} {.pop.}