File Coverage

blib/lib/Music/Factory.pm

Criterion	Covered	Total	%
statement	47	47	100.0
branch	8	8	100.0
condition	3	3	100.0
subroutine	8	8	100.0
pod			n/a
total	66	66	100.0

# -*- Perl -*-
#
# some factory class for your music factory class

package Music::Factory;
our $VERSION = '0.01';
use 5.26.0;
use warnings;
use Object::Pad 0.66;

# assembly line calls a generator object to fill an array of events up
# to a particular duration (musical section)
class Music::Factory::AssemblyLine {
    field $events :param;    # MIDI events (array ref)
    field $gen :param;       # generator object
    field $maxlen :param;    # maxiumum duration to generate

    method update ( $length = $maxlen ) {
        $gen->reset;          # NOTE may be removed
        my ( $epoch, $done, $overflow ) = ( 0, 0 );
        while (1) {
            my ( $dur, $elist ) = $gen->update( $epoch, $length );
            $epoch += $dur;
            if ( $epoch > $length ) {
                # kick overflows back to the caller to figure out, if
                # they care. generators can also do calculations to
                # avoid this situation, if they care
                $epoch -= $dur;
                $overflow = [ $dur, $elist ];
                last;
            } elsif ( $epoch == $length ) {
                $done = 1;
            }
            push $events->@*, $elist->@* if defined $elist and $elist->@*;
            last if $done;
        }
        return $epoch, $events, $overflow;
    }
}

# generator objects are called by an assembly line and generate events
# (an array reference) of some length (hopefully of the same duration as
# the events generated)
class Music::Factory::Generator {
    # NOTE reset() might be gotten rid of as a generator update() can
    # probably run similar code when $epoch == 0 but that would make the
    # update function a bit more complicated. if reset is common it
    # probably should be a distinct method, otherwise not?
    method reset () { }

    method update ( $epoch, $maxlen ) {
        die "need a better implementation";
    }
}

# a note of a particular duration; the pitch and velocity are done by
# function callbacks
class Music::Factory::Note :isa(Music::Factory::Generator) {
    field $chan :param = 0;    # MIDI channel
    field $pitch :param;       # callback
    field $velo :param;        # callback
    field $duration :param = 96;

    method update ( $epoch, $length ) {
        my $dur = $duration;
        # how to truncate to teh remaining length instead of
        # overflowing. whether this makes sense depends on what a
        # generator is doing. for example, if $dur is "too small" one
        # may instead want to insert silence of that amount
        #my $when = $epoch + $dur;
        #if ( $when > $length ) {
        #    $dur -= $when - $length;
        #    return $dur, [ [ note_off => $dur, $chan, 0, 0 ] ];
        #}
        my $p = $pitch->($epoch);
        return $duration,
          [ [ note_on  => 0,    $chan, $p, $velo->($epoch) ],
            [ note_off => $dur, $chan, $p, 0 ],
          ];
    }
}

# silence to fill the maximum duration given
class Music::Factory::Rest :isa(Music::Factory::Generator) {

    method update ( $epoch, $length ) {
        return $length, [ [ marker => $length, 'silence' ] ];
    }
}

1;
__END__