head

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

Audio::PortMIDI - Raku MIDI access using the portmidi library


code

=begin code

use Audio::PortMIDI;

my $pm = Audio::PortMIDI.new;

my $dev = $pm.default-output-device;

say $dev;


my $stream = $pm.open-output($dev, 32);

# Play 1/8th note middle C
my $note-on = Audio::PortMIDI::Event.new(event-type => NoteOn, channel => 1, data-one => 60, data-two => 127, timestamp => 0);
my $note-off = Audio::PortMIDI::Event.new(event-type => NoteOff, channel => 1, data-one => 60, data-two => 127, timestamp => 0);

$stream.write($note-on);
sleep .25;
$stream.write($note-off);

$stream.close;

$pm.terminate;

=end code


See also the examples directory in the distributtion for more complete examples.


This allows you to get MIDI data into or out of your Raku programs. It
provides the minimum abstraction to construct and unpack MIDI messages
and send and receive them via some interface available on your system,
be that ALSA on Linux, CoreMidi on Mac OS/X or whatever it is that
Windows uses.  Depending on the way that the portmidi library is built
there may be other interfaces available.


The MIDI specification itself doesn't particularly provide for the
arrangement of the events themselves in time and this is assumed to
be the responsibility of the calling application.


You almost certainly will want to familiarise yourself to some extent
with the L<MIDI protocol|http://www.midi.org> and especially the types
of messages that are sent as the interface of PortMIDI and hence this
module is fairly "close to the wire".


One thing that should be noted is that currently this uses the
default time source provided by the PortMIDI library, which you can
access in your own programs, if synchronization to an alternative
clock is required the native subroutines would support it, just not
available through the public interface at this time.


The majority of the methods will throw an exception C<X::PortMIDI>
if a problem is encountered with the underlying library call.


This is the constructor of the class, it will call C<initialize> and
start the default time source.


This initializes the portmidi library and should be called before using
any of the other methods, however it is called by the constructor so in
practice it should not be necessary in most programs.


This allows the portmidi libray to free up any resources it may have
allocated and close any connections, this may not be necessary in
short running programs but it is good practice to do it anyway ( I
have noticed no ill-effects on Linux but your system may differ.)


This returns the number of MIDI devices available on your system. The
devices are numbered 0 .. count-devices - 1.  Typically each physical
(or virtual device) will be counted as two devices if it provides both
input and output and may provide a different number of input and output
devices. If there is some problem enumerating the devices then an
exception will be thrown.


method device-info(Int $device-id) returns DeviceInfo


This returns a L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo>
object describing the device specified as the integer device ID, which
should be between 0 and count-devices - 1.  If the number is out of range
or there is some other problem getting the device information an exception
will be thrown.


This returns the list of all the devices on the system as
L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo> objects. which is
really just a shortcut combining the above two methods.  If there is a problem
getting the list then an exception will be thrown.


method default-input-device() returns DeviceInfo


This returns L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo>
representing the default device that can be used for input on your system
(if one is configured,) it may be be more or less useful depending on
the configuration of your MIDI system, for instance on Linux with ALSA
a default "MIDI Thru" device will always be created irrespective of the
presence of any other MIDI devices and this will usually be returned as
the default (for both input and output.)


method default-outpur-device() returns DeviceInfo


This returns L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo>
representing the default device that can be used for output on your system
(if one is configured,) it may be be more or less useful depending on
the configuration of your MIDI system, for instance on Linux with ALSA
a default "MIDI Thru" device will always be created irrespective of the
presence of any other MIDI devices and this will usually be returned as
the default (for both input and output.)


multi method open-input(DeviceInfo:D $dev, Int $buffer-size) returns Stream {
multi method open-input(Int $device-id, Int $buffer-size) returns Stream {


This opens the specified device (which can
be provided as either an integer device ID or a
L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo> object,)
for input returning a L<Audio::PortMIDI::Stream|#Audio::PortMIDI::Stream>
object.  If the device is not available for input then an exception will
be thrown.


The buffer size argument indicates the number of messages that should be
buffered and should be tailored to suit your application, if the number
of messages received without a read exceeds the size of the buffer then
an exception may be thrown at the time of the next read, so you may want
a higher value if you are expecting a high number of messages between
each opportunity to read, this may of course slightly increase overall
application latency.  If you have a large number of messages (clocks,
control changes, and so forth) that you are not interested in then you
may set a filter on the Stream to reduce the number that are buffered
for your application.


multi method open-output(DeviceInfo:D $dev, Int $buffer-size, Int $latency = 0 ) returns Stream {
multi method open-output(Int $device-id, Int $buffer-size, Int $latency = 0) returns Stream {


This opens the specified device (which can
be provided as either an integer device ID or a
L<Audio::PortMIDI::DeviceInfo|#Audio::PortMIDI::DeviceInfo> object,) for
output returning a L<Audio::PortMIDI::Stream|#Audio::PortMIDI::Stream>
object.  If the device is not available for output then an exception
will be thrown.


The buffer size argument is the maximum number of messages that can be
buffered before being sent out by the device, If you exceed the buffer
size then an exception will be thrown at the next attempt to write to the
device, however the rate for a standard MIDI (serial) device is just a
little less than a thousand messages a second so unless you are sending
many notes at once with high frequency then you are unlikely to need a
very large buffer.


The latency argument is a delay in milliseconds that is applied to
determine when the output of the message will actually occur.  If it
is set to 0 (the default,) then the timestamp on a message is basically
ignored and the message is sent immediately, if it is greater than 0 then
the message will be delayed until the timestamp on the message + latency
is equal to the application time reference.  The portmidi time reference
can be obtained from the L<Audio::PortMIDI::Time|#Audio::PortMIDI::Time>
class method C<time> and the timestamps should be constructed with
reference to that value if this feature is to be used.


This class represents a device that is returned by C<device-info> and can be opened for input
or output.


This is the integer device id of the device that may be passed to
C<open-input> or C<open-output>




use NativeCall;

class Audio::PortMIDI {

    constant LIB = ('portmidi',v0);

    enum Error (
        NoError             => 0,
        NoData              => 0,
        GotData             => 1,
        HostError           => -10000,
        InvalidDeviceId     => -9999,
        InsufficientMemory  => -9998,
        BufferTooSmall      => -9997,
        BufferOverflow      => -9996,
        BadPtr              => -9995,
        BadData             => -9994,
        InternalError       => -9993,
        BufferMaxSize       => -9992
    );

    sub Pm_GetErrorText(int32 $errnum) is native(LIB) returns Str { * }

    method error-text(Int $code) returns Str {
        Pm_GetErrorText($code);
    }

    sub Pm_GetHostErrorText(Buf $b, int32 $len) is native(LIB) { * }

    method host-error-text() returns Str {
        my Buf $buf = Buf.allocate(255);
        Pm_GetHostErrorText($buf, 255);
        $buf.decode;
    }

    class X::PortMIDI is Exception {
        has Int $.code is required;
        has Str $.what is required;
        has Str $.message;

        method message() returns Str {
            if !$!message.defined {
                my $text = Pm_GetErrorText($!code);
                if $!code ~~ HostError {
                    $text ~= ': ' ~ Audio::PortMIDI.host-error-text;
                }
                $!message = "{$!what} : $text";
            }
            $!message;
        }

    }

    my class DeviceInfoX is repr('CStruct') {
        has int32                         $.struct-version;
        has Str                           $.interface;
        has Str                           $.name;
        has int32                         $.input;
        has int32                         $.output;
        has int32                         $.opened;
    }

    class DeviceInfo {
        has DeviceInfoX $.device-info handles <interface name> is required;
        has Int $.device-id is required;

        method input() returns Bool {
            Bool($!device-info.input);
        }
        method output() returns Bool {
            Bool($!device-info.output);
        }
        method opened() returns Bool {
            Bool($!device-info.opened);
        }

        method gist() {
            sprintf "%3i :  %-25s  %10s  %2s   %3s   %4s", self.device-id,
                                                        self.name,
                                                        self.interface,
                                                        ( self.input ?? 'In' !! '--' ),
                                                        ( self.output ?? 'Out' !! '---' ),
                                                        (self.opened ?? 'Open' !! '----');
        }


    }

    # For some reason the nativecall can't deal with the pattern
    # we have here so we will cheat and pretend we're dealing with
    # a uint64 and unpack the parts ourself.

    class EventX is repr('CStruct') {
        has int32   $.message;
        has int32   $.timestamp;
    }

    use Util::Bitfield;

    class Event {
        enum Type is export (
            NoteOff             => 0b1000,
            NoteOn              => 0b1001,
            PolyphonicPressure  => 0b1010,
            ControlChange       => 0b1011,
            ProgramChange       => 0b1100,
            ChannelPressure     => 0b1101,
            PitchBend           => 0b1110,
            SystemMessage       => 0b1111,
        );
        enum RealTime is export (
            Clock       =>  0b11111000,
            Start       =>  0b11111010,
            Continue    =>  0b11111011,
            Stop        =>  0b11111100
        );

        has Int     $.message;
        has Int     $.timestamp;
        has Int     $.status;
        has Int     $.channel;
        has Type    $.event-type;
        has Int     $.data-one;
        has Int     $.data-two;

        submethod BUILD(Int :$event, Int :$!timestamp, Int :$!channel, Type :$!event-type, Int :$!data-one, Int :$!data-two, Int :$!status) {
            if $event.defined {
                $!timestamp = extract-bits($event,32,0,64);
                $!message   = extract-bits($event,32,32,64);
            }
        }

        method message() returns Int {
            if !$!message.defined {
               my $mess = 0;
               if self.status.defined {
                   $mess = insert-bits(self.status, $mess, 8, 16, 24 );
               }
               if self.data-one.defined {
                   $mess = insert-bits(self.data-one, $mess,8, 8, 24 );
               }
               if self.data-two.defined {
                   $mess = insert-bits(self.data-two, $mess,8, 0, 24);
               }
               $!message = $mess;
            }
            $!message;
        }

        method status() returns Int {
            if !$!status.defined {
                if $!message.defined {
                    $!status = extract-bits($!message,8,16,24);
                }
                elsif $!channel.defined && $!event-type.defined {
                    my $status = insert-bits($!event-type,0,4,0,8);
                    $!status = insert-bits($!channel, $status,4,4,8);
                }
            }
            $!status;
        }

        method channel() returns Int {
            if !$!channel.defined {
                if self.status.defined {
                    $!channel = extract-bits(self.status,4,4,8);
                }
            }
            $!channel;
        }
        method event-type() returns Int {
            if !$!event-type.defined  {
                if self.status.defined {
                    $!event-type = Type(extract-bits(self.status,4,0,8));
                }
            }
            $!event-type;
        }

        method data-one() returns Int {
            if !$!data-one.defined && $!message.defined {
                $!data-one = extract-bits($!message,8,8,24);
            }
            $!data-one;
        }
        method data-two() returns Int {
            if !$!data-two.defined  && $!message.defined {
                $!data-two = extract-bits($!message,8,0,24);
            }
            $!data-two;
        }

        method gist() returns Str {
            "Channel : { self.channel } Event: { self.event-type } D1 : { self.data-one } D2 : { self.data-two }";
        }

        method Int() returns Int {
            my $int = insert-bits(self.message // 0, 0, 32, 32, 64);
            insert-bits(self.timestamp // 0, $int, 32, 0, 64);
        }
    }

    enum Filter (
        Active => (1 +< 0x0E),
        Sysex => (1 +< 0x00),
        Clock => (1 +< 0x08),
        Play => ((1 +< 0x0A) +| (1 +< 0x0C) +| (1 +< 0x0B)),
        Tick => (1 +< 0x09),
        Fd => (1 +< 0x0D),
        Undefined => (1 +< 0x0D),
        Reset => (1 +< 0x0F),
        Realtime => ((1 +< 0x0E) +| (1 +< 0x00) +| (1 +< 0x08) +| (1 +< 0x0A) +| (1 +< 0x0C) +| (1 +< 0x0B) +| (1 +< 0x09) +| (1 +< 0x0D) +| (1 +< 0x0F)),
        Note => ((1 +< 0x19) +| (1 +< 0x18)),
        ChannelAftertouch => (1 +< 0x1D),
        PolyAftertouch => (1 +< 0x1A),
        Aftertouch => ((1 +< 0x1D) +| (1 +< 0x1A) ),
        Program => (1 +< 0x1C),
        Control => (1 +< 0x1B),
        Pitchbend => (1 +< 0x1E),
        Mtc => (1 +< 0x01),
        SongPosition => (1 +< 0x02),
        SongSelect => (1 +< 0x03),
        Tune => (1 +< 0x06),
        Systemcommon => ((1 +< 0x01) +| (1 +< 0x02) +| (1 +< 0x03) +| (1 +< 0x06)),
    );

    class StreamPointer is repr('CPointer') { }
    class Stream {
        has CArray[StreamPointer] $.ptr;
        has Channel $.ev-chan;
        has Promise $.ev-chan-promise;
        has Bool    $.running;
        has Channel $.rc-chan;
        has Stream  $!stream;

        submethod BUILD() {
            $!ptr = CArray[StreamPointer].new(StreamPointer.new());
            $!ev-chan = Channel.new;
            $!rc-chan = Channel.new;
            $!running = True;
            $!ev-chan-promise = start {
                while $!running {
                    my $ev = await $!ev-chan;
                    my $rc = $ev<call>(|@($ev<args>));
                    $!rc-chan.send($rc) unless $!rc-chan.closed;
                }
            }
        }

        sub Pm_HasHostError(StreamPointer $stream) is native(LIB) returns int32 { * }

        method has-host-error() returns Bool {
            my $rc = Pm_HasHostError($.ptr[0]);
            Bool($rc);
        }

        sub Pm_SetFilter(StreamPointer $stream , int32 $filters) is native(LIB) returns int32 { * }

        method set-filter(Int $filter) {
            $.ev-chan.send(%(call => &Pm_SetFilter, args => [$.ptr[0], $filter]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => 'setting filter').throw;
            }
            True;
        }

        sub Pm_SetChannelMask(StreamPointer $stream, int32 $mask ) is native(LIB) returns int32 { * }

        method set-channel-mask(*@channels where { @channels.elems <= 16 && all(@channels) ~~ ( 0 ..15 ) }) {
            my int $mask = @channels.map(1 +< *).reduce(&[+|]);
            $.ev-chan.send(%(call => &Pm_SetChannelMask, args => [$.ptr[0], $mask]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => 'setting channel mask').throw;
            }
            True;
        }

        sub Pm_Abort(StreamPointer $stream) is native(LIB) returns int32 { * }

        method abort() {
            $!running = False;
            $.ev-chan.fail;
            # await $.ev-chan-promise;
            # $.ev-chan.close;
            $.rc-chan.fail;
            my $rc = Pm_Abort($.ptr[0]);
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "aborting stream").throw;
            }
        }

        sub Pm_Close(StreamPointer $stream) is native(LIB) returns int32 { * }

        method close() {
            $.ev-chan.send(%(call => &note, args => ["Closing Stream"]));
            $!running = False;
            $.ev-chan.close;
            $.rc-chan.close;
            await $.ev-chan-promise;
            my $rc = Pm_Close($.ptr[0]);
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "closing stream").throw;
            }
        }

        sub Pm_Synchronize(StreamPointer $stream ) is native(LIB) returns int32 { * }

        method synchronize() {
            $.ev-chan.send(%(call => &Pm_Synchronize, args => [$.ptr[0]]));
            my $rc = $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "synchronizing stream").throw;
            }
        }


        sub Pm_Poll(StreamPointer $stream ) is native(LIB) returns int32 { * }

        method poll() returns Bool {
            $.ev-chan.send(%(call => &Pm_Poll, args => [$.ptr[0]]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "polling stream").throw;
            }
            Bool($rc);
        }

        sub Pm_Read(StreamPointer $stream, CArray $buffer, int32 $length) is native(LIB) returns int32 { * }


        proto method read(|c) { * }

        multi method read(Int $length) {
            my CArray[int64] $buff = CArray[int64].new;
            $buff[$length - 1] = 0;
            $.ev-chan.send(%(call => &Pm_Read, args => [$.ptr[0], $buff, $length]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "reading stream").throw;
            }

            my @buff;

            for ^$rc -> $i {
                @buff.append: Event.new(event => $buff[$i]);
            }

            @buff;
        }

        sub Pm_Write(StreamPointer $stream, CArray[int64] $buffer, int32  $length ) is native(LIB) returns int32 { * }

        proto method write(|c) { * }

        multi method write(Event @events) {
            my $buffer = CArray[int64].new;
            my $length = @events.elems;
            for @events -> $event {
                $buffer[$++] = $event.Int;
            }
            $.ev-chan.send(%(call => &Pm_Write, args => [$.ptr[0], $buffer, $length]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "writing stream").throw;
            }
        }

        sub Pm_WriteShort(StreamPointer $stream, int32 $when, int32 $msg) is native(LIB) returns int32 { * }

        multi method write(Event $event) {
            $.ev-chan.send(%(call => &Pm_WriteShort, args => [$.ptr[0], $event.timestamp // 0, $event.message]));
            my $rc = await $.rc-chan;
            if $rc < 0 {
                X::PortMIDI.new(code => $rc, what => "writing stream").throw;
            }
        }

        sub Pm_WriteSysEx(StreamPointer $stream, int32 $when, Pointer[uint8] $msg) is native(LIB) returns int32 { * }
    }

    class Time {

        sub Pt_Started() returns int32 is native(LIB) { * }

        method started() returns Bool {
            my $rc = Pt_Started();
            Bool($rc);
        }
        sub Pt_Start(int32 $resolution, &ccb (int32 $timestamp, Pointer $userdata), Pointer $u) returns int32 is native(LIB) { * }

        method start() {
            Pt_Start(1, Pointer, Pointer);
        }

        sub Pt_Time() returns int32 is native(LIB) { * }

        method time() returns Int {
            Pt_Time();
        }
    }


    multi submethod BUILD() {
        self.initialize();
        Time.start();
    }

    sub Pm_Initialize() is native(LIB) returns int32 { * }

    method initialize() {
        my $rc = Pm_Initialize();
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => 'initialising portmidi').throw;
        }
    }

    sub Pm_Terminate() is native(LIB) returns int32  { * }

    method terminate() {
        my $rc = Pm_Terminate();
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => 'terminating portmidi').throw;
        }
    }

    sub Pm_CountDevices() is native(LIB) returns int32 { * }

    method count-devices() returns Int {
        my $rc = Pm_CountDevices();
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => 'count-devices').throw;
        }
        $rc;
    }

    sub Pm_GetDeviceInfo(int32 $id) is native(LIB) returns DeviceInfoX { * }

    method device-info(Int $device-id) returns DeviceInfo {
        DeviceInfo.new(device-info => Pm_GetDeviceInfo($device-id), :$device-id);
    }

    method devices() {
        gather {
            for ^(self.count-devices()) -> $id {
                take self.device-info($id);
            }
        }
    }

    sub Pm_GetDefaultInputDeviceID() is native(LIB) returns int32 { * }

    method default-input-device() returns DeviceInfo {
        my $rc = Pm_GetDefaultInputDeviceID();
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => "default-input-device").throw;
        }
        self.device-info($rc);
    }

    sub Pm_GetDefaultOutputDeviceID() is native(LIB) returns int32 { * }

    method default-output-device() returns DeviceInfo {
        my $rc = Pm_GetDefaultOutputDeviceID();
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => "default-output-device").throw;
        }
        self.device-info($rc);
    }

    sub Pm_OpenInput(CArray[StreamPointer] $stream, int32 $inputDevice, Pointer $inputDriverInfo, int32 $bufferSize ,&time_proc (Pointer --> int32), Pointer $time_info) is native(LIB) returns int32 { * }

    proto method open-input(|c) { * }

    multi method open-input(DeviceInfo:D $dev, Int $buffer-size) returns Stream {
        if $dev.input {
            self.open-input($dev.device-id, $buffer-size);
        }
        else {
            X::PortMIDI.new(code => -9999, message => "not an input device", what => "opening input stream").throw;
        }
    }

    multi method open-input(Int $device-id, Int $buffer-size) returns Stream {
        my $stream = Stream.new;
        my $rc = Pm_OpenInput($stream.ptr, $device-id, Pointer, $buffer-size, Pointer, Pointer);
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => "opening input stream").throw;
        }
        $stream;
    }

    sub Pm_OpenOutput(CArray[StreamPointer] $stream, int32 $outputDevice, Pointer $outputDriverInfo, int32 $bufferSize ,&time_proc (Pointer --> int32), Pointer $time_info, int32 $latency) is native(LIB) returns int32 { * }


    proto method open-output(|c) { * }


    multi method open-output(DeviceInfo:D $dev, Int $buffer-size, Int $latency = 0 ) returns Stream {
        if $dev.output {
            self.open-output($dev.device-id, $buffer-size, $latency);
        }
        else {
            X::PortMIDI.new(code => -9999, message => "not an output device", what => "opening output stream").throw;
        }
    }

    multi method open-output(Int $device-id, Int $buffer-size, Int $latency = 0) returns Stream {
        my $stream = Stream.new;
        my $rc = Pm_OpenOutput($stream.ptr, $device-id, Pointer, $buffer-size, Pointer, Pointer, $latency);
        if $rc < 0 {
            X::PortMIDI.new(code => $rc, what => "opening output stream").throw;
        }
        $stream;
    }
}

# vim: expandtab shiftwidth=4 ft=raku


PortMIDI

Image

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Examples for Audio::PortMIDI

show-devices

dump-stream

wonky-clock

mode-play

amen

Audio::PortMIDI v0.0.12

Authors

License

Dependencies

Test Dependencies

Provides

Documentation