From bac145fc43335a1d992d50f921d16a0dc40c8dcd Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Fri, 1 May 2020 17:26:13 -0400 Subject: [PATCH] Upgrade to julia 1.0 --- Project.toml | 14 +++++++++ REQUIRE | 3 -- src/JACKAudio.jl | 78 +++++++++++++++++++++++------------------------- src/libjack.jl | 34 ++++++++++----------- test/REQUIRE | 2 -- test/runtests.jl | 9 +----- 6 files changed, 69 insertions(+), 71 deletions(-) create mode 100644 Project.toml delete mode 100644 REQUIRE delete mode 100644 test/REQUIRE diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..bcb4eb5 --- /dev/null +++ b/Project.toml @@ -0,0 +1,14 @@ +name = "JACKAudio" +uuid = "e15094ee-46e5-4090-b60c-bc5c382a8256" +version = "0.1.0" + +[deps] +SampledSignals = "bd7594eb-a658-542f-9e75-4c4d8908c167" +Sockets = "6462fe0b-24de-5631-8697-dd941f90decc" + +[extras] +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[targets] +test = ["Test"] + diff --git a/REQUIRE b/REQUIRE deleted file mode 100644 index 2887245..0000000 --- a/REQUIRE +++ /dev/null @@ -1,3 +0,0 @@ -julia 0.4 -SampledSignals 0.3.0 -Compat 0.8.6 diff --git a/src/JACKAudio.jl b/src/JACKAudio.jl index ccf9b9b..d559042 100644 --- a/src/JACKAudio.jl +++ b/src/JACKAudio.jl @@ -1,13 +1,9 @@ -__precompile__() - module JACKAudio -using Compat -import Compat.ASCIIString - using SampledSignals import SampledSignals: nchannels, samplerate, nframes using Base.Libc: malloc, free +using Sockets export JACKClient, sources, sinks, seekavailable @@ -25,19 +21,6 @@ const RINGBUF_SAMPLES = 131072 # detect an overflow. const OVERFLOW_ADVANCE = 8192 -function __init__() - global const process_cb = cfunction(process, Cint, (NFrames, Ptr{Ptr{Void}})) - global const shutdown_cb = cfunction(shutdown, Void, (Ptr{JACKClient}, )) - global const info_handler_cb = cfunction(info_handler, Void, (Cstring, )) - global const error_handler_cb = cfunction(error_handler, Void, (Cstring, )) - - - ccall((:jack_set_info_function, :libjack), Void, (Ptr{Void},), - info_handler_cb) - ccall((:jack_set_error_function, :libjack), Void, (Ptr{Void},), - error_handler_cb) -end - function error_handler(msg) println("libjack: ERROR: $(unsafe_string(msg))") @@ -55,8 +38,8 @@ ringbuffer to get data in and out of the process callback and a julia RingBuffer object that can be used for additional buffering. One important difference is that if the jack ringbuffer fills up it can't be written to, but the Julia RingBuffer maintains the last N samples""" -immutable JACKPort - name::ASCIIString +struct JACKPort + name::String ptr::PortPtr jackbuf::RingBufPtr @@ -86,10 +69,10 @@ for (T, Super, porttype) in as a group. There can be multiple JACKSources and JACKSinks in a JACKClient, and all the sources and sinks in a client get updated by the same `process` method.""" - @eval immutable $T <: $Super - name::ASCIIString + @eval struct $T <: $Super + name::String client::ClientPtr - clientname::ASCIIString + clientname::String ports::Vector{JACKPort} ringcondition::Condition # used to synchronize any in-progress transations @@ -136,22 +119,22 @@ end multiple `JACKSource`s and `JACKSink`s. It is automatically activated when it is constructed, so the sources and sinks are available for reading and writing, respectively.""" -type JACKClient - name::ASCIIString +mutable struct JACKClient + name::String ptr::ClientPtr sources::Vector{JACKSource} sinks::Vector{JACKSink} # this is memory allocated separately with malloc that is used to give the # process callback all the pointers it needs for the source/sink ports and # ringbuffers - portptrs::Ptr{Ptr{Void}} - callback::Base.SingleAsyncWork + portptrs::Ptr{Ptr{Nothing}} + callback::Base.AsyncCondition # this constructor takes a list of name, channelcount pairs - function JACKClient{T1 <: Tuple, T2 <: Tuple}( + function JACKClient( name::AbstractString="Julia", - sources::Vector{T1}=[("In", 2)], - sinks::Vector{T2}=[("Out", 2)]; + sources::Vector{<:Tuple}=[("In", 2)], + sinks::Vector{<:Tuple}=[("Out", 2)]; connect=true, active=true) status = Ref{Cint}(Failure) clientptr = jack_client_open(name, 0, status) @@ -175,7 +158,7 @@ type JACKClient nptrs = 2nsources + 2nsinks + 3 # TODO: we can switch this malloc and unsafe_store business # to an array we push! to - portptrs = Ptr{Ptr{Void}}(malloc(nptrs*sizeof(Ptr{Void}))) + portptrs = Ptr{Ptr{Nothing}}(malloc(nptrs*sizeof(Ptr{Nothing}))) if isnullptr(portptrs) jack_client_close(clientptr) error("Failure allocating memory for JACK client \"$name\"") @@ -226,7 +209,7 @@ type JACKClient unsafe_store!(portptrs, C_NULL, ptridx) ptridx += 1 - client.callback = Base.SingleAsyncWork(data -> managebuffers(client)) + client.callback = Base.AsyncCondition(data -> managebuffers(client)) # and finally we store the callback handle so the JACK process callback # can trigger the managebuffers function to run in the julia context @@ -264,8 +247,8 @@ JACKClient(sourcecount::Integer, sinkcount::Integer; kwargs...) = function Base.show(io::IO, client::JACKClient) print(io, "JACKClient(\"$(client.name)\", [") - sources = ASCIIString["(\"$(source.name)\", $(nchannels(source)))" for source in client.sources] - sinks = ASCIIString["(\"$(sink.name)\", $(nchannels(sink)))" for sink in client.sinks] + sources = String["(\"$(source.name)\", $(nchannels(source)))" for source in client.sources] + sinks = String["(\"$(sink.name)\", $(nchannels(sink)))" for sink in client.sinks] join(io, sources, ", ") print(io, "], [") join(io, sinks, ", ") @@ -309,10 +292,10 @@ sinks(client::JACKClient) = client.sinks Base.read!(client::JACKClient, args...) = read!(client.sources[1], args...) Base.read(client::JACKClient, args...) = read(client.sources[1], args...) Base.write(client::JACKClient, args...) = write(client.sinks[1], args...) -Base.connect(c1::JACKClient, c2::JACKClient) = connect(c1.sinks[1], c2.sources[1]) +Sockets.connect(c1::JACKClient, c2::JACKClient) = connect(c1.sinks[1], c2.sources[1]) # TODO: julia PR to extend Base.isnull rather than using isnullptr -isnullptr(ptr::Ptr) = Ptr{Void}(ptr) == C_NULL +isnullptr(ptr::Ptr) = Ptr{Nothing}(ptr) == C_NULL isnullptr(ptr::Cstring) = Ptr{Cchar}(ptr) == C_NULL """Connect the given client to the physical input/output ports, by just matching @@ -356,7 +339,7 @@ function autoconnect(client::JACKClient) end end -function Base.connect(sink::JACKSink, source::JACKSource) +function Sockets.connect(sink::JACKSink, source::JACKSource) for (sinkport, sourceport) in zip(sink.ports, source.ports) sinkportname = string(sink.clientname, ":", sinkport.name) sourceportname = string(source.clientname, ":", sourceport.name) @@ -570,13 +553,13 @@ function process(nframes, portptrs) # notify the managebuffers, which will get called with a reference to # this client - ccall(:uv_async_send, Void, (Ptr{Void},), handle) + ccall(:uv_async_send, Nothing, (Ptr{Nothing},), handle) Cint(0) end """Returns the largest x <= value s.t. x has the given alignment (in bytes)""" -align{T<:Unsigned}(value::T, alignment::Integer) = value & ~(T(alignment-1)) +align(value::T, alignment::Integer) where T<:Unsigned = value & ~(T(alignment-1)) sampalign(value) = align(value, sizeof(JACKSample)) # this callback gets called from within the Julia event loop, but is triggered @@ -603,9 +586,22 @@ function shutdown(arg) nothing end -memset(buf, val, count) = ccall(:memset, Ptr{Void}, - (Ptr{Void}, Cint, Csize_t), +memset(buf, val, count) = ccall(:memset, Ptr{Nothing}, + (Ptr{Nothing}, Cint, Csize_t), buf, 0, count) +function __init__() + global process_cb = @cfunction(process, Cint, (NFrames, Ptr{Ptr{Nothing}})) + global shutdown_cb = @cfunction(shutdown, Nothing, (Ptr{JACKClient}, )) + global info_handler_cb = @cfunction(info_handler, Nothing, (Cstring, )) + global error_handler_cb = @cfunction(error_handler, Nothing, (Cstring, )) + + + ccall((:jack_set_info_function, :libjack), Nothing, (Ptr{Nothing},), + info_handler_cb) + ccall((:jack_set_error_function, :libjack), Nothing, (Ptr{Nothing},), + error_handler_cb) +end + end # module diff --git a/src/libjack.jl b/src/libjack.jl index 4735b4c..4ec869b 100644 --- a/src/libjack.jl +++ b/src/libjack.jl @@ -1,13 +1,13 @@ -typealias ClientPtr Ptr{Void} -typealias PortPtr Ptr{Void} -typealias CFunPtr Ptr{Void} -typealias NFrames UInt32 -typealias JACKSample Cfloat +const ClientPtr = Ptr{Nothing} +const PortPtr = Ptr{Nothing} +const CFunPtr = Ptr{Nothing} +const NFrames = UInt32 +const JACKSample = Cfloat const JACK_DEFAULT_AUDIO_TYPE = "32 bit float mono audio" # this mirrors the struct defined in ringbuffer.h -type RingBuf +mutable struct RingBuf buf::Ptr{Cchar} write_ptr::Csize_t read_ptr::Csize_t @@ -16,7 +16,7 @@ type RingBuf mlocked::Cint end # add typealias for consistency with other *Ptr types -typealias RingBufPtr Ptr{RingBuf} +const RingBufPtr = Ptr{RingBuf} @enum(Option, # Null value to use when no option bits are needed. @@ -41,7 +41,7 @@ typealias RingBufPtr Ptr{RingBuf} SessionID = 0x20) # useful for OR'ing options together -@compat Base.:|(l::Option, r::Option) = UInt(l) | UInt(r) +Base.:|(l::Option, r::Option) = UInt(l) | UInt(r) @enum(PortFlag, PortIsInput = 0x01, @@ -50,7 +50,7 @@ typealias RingBufPtr Ptr{RingBuf} PortCanMonitor = 0x08, PortIsTerminal = 0x10) -@compat Base.:|(l::PortFlag, r::PortFlag) = UInt(l) | UInt(r) +Base.:|(l::PortFlag, r::PortFlag) = UInt(l) | UInt(r) # some functions also return a -1 on failure @enum(Status, @@ -94,7 +94,7 @@ typealias RingBufPtr Ptr{RingBuf} status_str(status::Status) = string(status) # use & syntax for checking a flag, but return a boolean -@compat Base.:&{T <: Integer}(val::T, status::Status) = val & T(status) != 0 +Base.:&(val::Integer, status::Status) = val & T(status) != 0 function status_str(status::Integer) if status == -1 @@ -125,12 +125,12 @@ jack_get_sample_rate(client) = jack_set_process_callback(client, callback, userdata) = ccall((:jack_set_process_callback, :libjack), Cint, - (ClientPtr, CFunPtr, Ptr{Void}), + (ClientPtr, CFunPtr, Ptr{Nothing}), client, callback, userdata) jack_on_shutdown(client, callback, userdata) = ccall((:jack_on_shutdown, :libjack), Cint, - (ClientPtr, CFunPtr, Ptr{Void}), + (ClientPtr, CFunPtr, Ptr{Nothing}), client, callback, userdata) jack_get_ports(client, portname, typename, flags) = @@ -142,7 +142,7 @@ jack_connect(client, src, dest) = ccall((:jack_connect, :libjack), Cint, (ClientPtr, Cstring, Cstring), client, src, dest) -jack_free(ptr) = ccall((:jack_free, :libjack), Void, (Ptr{Void}, ), ptr) +jack_free(ptr) = ccall((:jack_free, :libjack), Nothing, (Ptr{Nothing}, ), ptr) jack_port_register(client, portname, porttype, flags, bufsize) = ccall((:jack_port_register, :libjack), PortPtr, @@ -162,14 +162,14 @@ jack_ringbuffer_create(bytes) = ccall((:jack_ringbuffer_create, :libjack), Ptr{RingBuf}, (Csize_t, ), bytes) jack_ringbuffer_free(buf) = - ccall((:jack_ringbuffer_free, :libjack), Void, (Ptr{RingBuf}, ), buf) + ccall((:jack_ringbuffer_free, :libjack), Nothing, (Ptr{RingBuf}, ), buf) jack_ringbuffer_read(ringbuf, dest, bytes) = ccall((:jack_ringbuffer_read, :libjack), Csize_t, - (Ptr{RingBuf}, Ptr{Void}, Csize_t), ringbuf, dest, bytes) + (Ptr{RingBuf}, Ptr{Nothing}, Csize_t), ringbuf, dest, bytes) jack_ringbuffer_read_advance(ringbuf, bytes) = - ccall((:jack_ringbuffer_read_advance, :libjack), Void, + ccall((:jack_ringbuffer_read_advance, :libjack), Nothing, (Ptr{RingBuf}, Csize_t), ringbuf, bytes) jack_ringbuffer_read_space(ringbuf) = @@ -178,7 +178,7 @@ jack_ringbuffer_read_space(ringbuf) = jack_ringbuffer_write(ringbuf, src, bytes) = ccall((:jack_ringbuffer_write, :libjack), Csize_t, - (Ptr{RingBuf}, Ptr{Void}, Csize_t), ringbuf, src, bytes) + (Ptr{RingBuf}, Ptr{Nothing}, Csize_t), ringbuf, src, bytes) jack_ringbuffer_write_space(ringbuf) = ccall((:jack_ringbuffer_write_space, :libjack), Csize_t, diff --git a/test/REQUIRE b/test/REQUIRE deleted file mode 100644 index 58490e3..0000000 --- a/test/REQUIRE +++ /dev/null @@ -1,2 +0,0 @@ -julia 0.4 -BaseTestNext diff --git a/test/runtests.jl b/test/runtests.jl index f265ba9..19bb702 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,13 +1,6 @@ module JACKAudioTests -using Compat -import Compat.ASCIIString - -if VERSION >= v"0.5.0-" - using Base.Test -else - using BaseTestNext -end +using Test using JACKAudio using SampledSignals