File Coverage

blib/lib/MIDI/RtController/Filter/CC.pm

Criterion	Covered	Total	%
statement	29	224	12.9
branch	0	68	0.0
condition	0	49	0.0
subroutine	10	26	38.4
pod	9	9	100.0
total	48	376	12.7

package MIDI::RtController::Filter::CC;
our $AUTHORITY = 'cpan:GENE';

# ABSTRACT: Control-change based RtController filters

our $VERSION = '0.1200';

use v5.36;

use strictures 2;
use curry;
use IO::Async::Timer::Countdown ();
use IO::Async::Timer::Periodic ();
use Iterator::Breathe ();
use Moo;
use Types::MIDI qw(Velocity);
use Types::Common::Numeric qw(PositiveNum);
use namespace::clean;

extends 'MIDI::RtController::Filter';


has control => (
    is      => 'rw',
    isa     => Velocity, # no CC# in Types::MIDI yet
    default => 1,
);


has initial_point => (
    is      => 'rw',
    isa     => Velocity, # no CC# msg value in Types::MIDI yet
    default => 0,
);


has range_bottom => (
    is      => 'rw',
    isa     => Velocity, # no CC# msg value in Types::MIDI yet
    default => 0,
);


has range_top => (
    is      => 'rw',
    isa     => Velocity, # no CC# msg value in Types::MIDI yet
    default => 127,
);


has range_step => (
    is      => 'rw',
    isa     => Velocity, # no CC# msg value in Types::MIDI yet
    default => 1,
);


has time_step => (
    is      => 'rw',
    isa     => PositiveNum,
    default => 0.25,
);


has step_up => (
    is      => 'rw',
    isa     => Velocity, # no CC# in Types::MIDI yet
    default => 2,
);


has step_down => (
    is      => 'rw',
    isa     => Velocity, # no CC# in Types::MIDI yet
    default => 1,
);


sub add_filters ($filters, $controllers) {
    for my $params (@$filters) {
        my $port = delete $params->{port};
        # skip unnamed and unknown entries
        next if !$port || !exists $controllers->{$port};
        my $type = delete $params->{type} || 'single';
        my $event = delete $params->{event} || 'all';
        my $filter = __PACKAGE__->new(
            rtc => $controllers->{$port}
        );
        # assume all remaining key/values are module attributes
        for my $param (keys %$params) {
            $filter->$param($params->{$param});
        }
        my $method = "curry::$type";
        $controllers->{$port}->add_filter($type, $event => $filter->$method);
    }
}


sub single ($self, $device, $dt, $event) {
    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;

    my $value = $self->value // $val;
    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
    $self->rtc->send_it($cc);

    return $self->continue;
}


sub clock_it ($self, $device, $dt, $event) {
    return 0 if $self->running;

    $self->running(1);

    $self->rtc->send_it(['start']);

    $self->rtc->loop->add(
        IO::Async::Timer::Periodic->new(
            interval  => $self->time_step,
            on_tick => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $self->rtc->send_it(['stop']);
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    $self->rtc->send_it(['clock']);
                }
            },
        )->start
    );

    return $self->continue;
}


sub breathe ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $it = Iterator::Breathe->new(
        bottom => $self->range_bottom,
        top    => $self->range_top,
        step   => $self->range_step,
    );

    $self->rtc->loop->add(
        IO::Async::Timer::Periodic->new(
            interval  => $self->time_step,
            on_tick => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    $it->iterate;
                    my $cc = [ 'control_change', $self->channel, $self->control, $it->i ];
                    $self->rtc->send_it($cc);
                }
            },
        )->start
    );

    return $self->continue;
}


sub scatter ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $value  = $self->initial_point;
    my @values = ($self->range_bottom .. $self->range_top);

    $self->rtc->loop->add(
        IO::Async::Timer::Periodic->new(
            interval  => $self->time_step,
            on_tick => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
                    $self->rtc->send_it($cc);
                    $value = $values[ int rand @values ];
                }
            },
        )->start
    );

    return $self->continue;
}


sub stair_step ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $it = Iterator::Breathe->new(
        bottom => $self->range_bottom,
        top    => $self->range_top,
    );

    my $value     = $self->initial_point;
    my $direction = 1; # up

    $self->rtc->loop->add(
        IO::Async::Timer::Periodic->new(
            interval  => $self->time_step,
            on_tick => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
                    $self->rtc->send_it($cc);

                    # compute the stair-stepping
                    if ($direction) {
                        $it->step($self->step_up);
                    }
                    else {
                        $it->step(- $self->step_down);
                    }

                    # toggle the stair-step direction
                    $direction = !$direction;

                    # iterate the breathing
                    $it->iterate;
                    $value = $it->i;
                    $value = $self->range_top    if $value >= $self->range_top;
                    $value = $self->range_bottom if $value <= $self->range_bottom;
                }
            },
        )->start
    );
    return $self->continue;
}


sub ramp_up ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $value = $self->initial_point;

    $self->rtc->loop->add(
        IO::Async::Timer::Countdown->new(
            delay     => $self->time_step,
            on_expire => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
                    $self->rtc->send_it($cc);

                    $value += $self->range_step;

                    if ($value > $self->range_top) {
                        $c->stop;
                        $self->running(0);
                    }
                    else {
                        $c->start;
                    }
                }
            },
        )->start
    );

    return $self->continue;
}


sub ramp_down ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $value = $self->initial_point;

    $self->rtc->loop->add(
        IO::Async::Timer::Countdown->new(
            delay     => $self->time_step,
            on_expire => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
                    $self->rtc->send_it($cc);

                    $value -= $self->range_step;

                    if ($value < $self->range_bottom) {
                        $c->stop;
                        $self->running(0);
                    }
                    else {
                        $c->start;
                    }
                }
            },
        )->start
    );

    return $self->continue;
}


sub flicker ($self, $device, $dt, $event) {
    return 0 if $self->running;

    my ($ev, $chan, $note, $val) = $event->@*;
    return 0 if defined $self->trigger && $note != $self->trigger;
    return 0 if defined $self->value && $val != $self->value;

    $self->running(1);

    my $value = $self->range_bottom;

    $self->rtc->loop->add(
        IO::Async::Timer::Countdown->new(
            delay     => $self->time_step,
            on_expire => sub {
                my ($c) = @_;
                if ($self->halt) {
                    $c->stop;
                    $self->running(0);
                    $self->halt(0);
                }
                else {
                    my $cc = [ 'control_change', $self->channel, $self->control, $value ];
                    $self->rtc->send_it($cc);
                    $value = $value == $self->range_top ? $self->range_bottom : $self->range_top;
                    $c->start;
                }
            },
        )->start
    );

    return $self->continue;
}

1;

__END__