/ 
MIDI-Simple-Drummer-0.00_21
River stage one • 1 direct dependent • 1 total dependent
/ MIDI::Simple::Drummer

NAME

MIDI::Simple::Drummer - Glorified Metronome

ABSTRACT

Is there a drummer in the house?

SYNOPSIS

# A glorified metronome:
use MIDI::Simple::Drummer;
my $d = MIDI::Simple::Drummer->new(-bpm => 100);
$d->count_in;
for(1 .. $d->phrases * $d->beats) {
  $d->note($d->EIGHTH, $d->backbeat_rhythm(-beat => $_));
  $d->note($d->EIGHTH, $d->tick);
}

# A smarter drummer:
use MIDI::Simple::Drummer::Rock;
$d = MIDI::Simple::Drummer::Rock->new(-bpm => 100);
my($beat, $fill) = (0, 0);
$d->count_in;
for my $p (1 .. $d->phrases) {
  if($p % 2 > 0) {
      $beat = $d->beat(-name => 'rock_3', -fill => $fill);
  }
  else {
      $beat = $d->beat(-name => 'rock_4');
      $fill = $d->fill(-last => $fill);
  }
}
$d->patterns(fin => \&fin);
$d->beat(-name => 'fin');
$d->write;
sub fin {
  my $d = shift;
  $d->note($d->EIGHTH, $d->option_strike;
  $d->note($d->EIGHTH, $d->strike('Splash Cymbal','Bass Drum 1'));
  $d->note($d->SIXTEENTH, $d->snare) for 0 .. 2;
  $d->rest($d->SIXTEENTH);
  $d->note($d->EIGHTH, $d->strike('Splash Cymbal','Bass Drum 1'));
}

DESCRIPTION

This module is embroyonic but may yet grow into a giant reptilian monster that smashes Tokyo.

Until then, this is a robotic drummer that hides MIDI::Simple details. It is not a "drum machine", that you program with verbose or arcane syntax. Rather, it is a "sufficiently intelligent" drummer (if that's not a contradiction of terms!<sting!>) with which you can practice and improvise.

Also, since these "patterns" are entirely perl, any available method can be used to generate the phrases: stochastic, evolutionary, l-system, recursive descent grammar, whatever.

Note that you, the programmer, should know what the patterns and kit elements are named and what they do. For these, check out the source of this package and the included style subclass(es).

The default kit is the exciting, general MIDI drumkit. Fortunately, you can import the .mid file into your favorite sequencer and assign better patches. Voila!

METHODS

new()

my $d = MIDI::Simple::Drummer->new(%arguments);

Far away in a distant galaxy... But nevermind that, Luke: use The Source.

Currently, the accepted => default attributes are:

# MIDI
Channel => '9',
Volume => '100',
# Rhythm
Style => Rock,
Accent => 30,
Bpm => 120,
Phrases => 4,
Beats => 4,
# The Goods[TM].
File => 'Drummer.mid',
Kit => This set by the API,
Patterns => This also set by the API,
Score => MIDI::Simple->new_score (set by the API),

These can all be overridden with the constuctor or accessors.

volume()

$x = $d->volume;
$x = $d->volume($y);

Return or set the volume.

bpm()

Beats per minute.

phrases()

Number of phrases to play.

beats()

Number of beats per measure.

score()

$x = $d->score;
$x = $d->score($y);
$x = $d->score($y, 'V127');
$x = $d->score($volume);

Return or set the "score" in MIDI::Simple object.

If there are any other arguments, they are set as score no-ops.

channel()

MIDI channel.

file()

Name for the .mid file to write.

patterns()

Return or set known style patterns.

accent()

Either return the current volume plus the accent increment or set the accent increment. This has an upper limit of MIDI fff.

strike()

$x = $d->strike;
$x = $d->strike('Cowbell');
$x = $d->strike('Cowbell','Tambourine');
@x = $d->strike('Cowbell','Tambourine');

Return note values for percussion names from the standard MIDI percussion set (with "notenum2percussion" in MIDI) in either scalar or list context. (Default predefined snare patch.)

option_strike()

$x = $d->option_strike;
$x = $d->option_strike('Short Guiro','Short Whistle','Vibraslap');

Return a note value from a list of patches (default predefined crash cymbals). If another set of patches is given, one of those is chosen at random.

note()

$d->note($d->SIXTEENTH, $d->snare);
$d->note('sn', 'n38');

Add a note to the score. This is a pass-through to "n" in MIDI::Simple.

rest()

$d->rest($d->SIXTEENTH);
$d->rest('sn');

Add a rest to the score. This is a pass-through to "r" in MIDI::Simple.

no_op()

$d->no_op('V127');

Add a no-op to the score. This is a pass-through to "noop" in MIDI::Simple.

metronome()

$d->metronome;
$d->metronome('Mute Triangle');

Add beats * phases of the Pedal Hi-Hat, unless another patch is provided.

count_in()

$d->count_in;
$d->count_in(2);
$d->count_in(1, 'Side Stick');

And a-one and a-two and a-one, two, three!</Lawrence Welk> ..11</FZ>

If No arguments are provided, the Closed Hi-Hat is used.

rotate()

$x = $d->rotate;
$x = $d->rotate(3);
$x = $d->rotate(5, ['Mute Hi Conga','Open Hi Conga','Low Conga']);

Rotate through a list of patches according to the given beat number. (Default backbeat patches.)

backbeat_rhythm()

$x = $d->backbeat_rhythm;
$x = $d->backbeat_rhythm(-beat => $y);
$x = $d->backbeat_rhythm(-fill => $z);
$x = $d->backbeat_rhythm(-patches => ['Cowbell','Hand Clap']);
$x = $d->backbeat_rhythm(-backbeat => ['Bass Drum 1','Electric Snare']);
$x = $d->backbeat_rhythm(-tick => ['Claves']);

Return the rotating backbeat with either the tick or an option patch (default crashes), if it's the first beat and we just filled.

beat()

$x = $d->beat;
$x = $d->beat(-name => $n);
$x = $d->beat(-last => $y);
$x = $d->beat(-fill => $z);
$x = $d->beat(-type => 'fill');

Play a beat type and return the id for the selected pattern. Beats and fills are both just patterns but drummers think of them as distinct animals.

This method adds an anecdotal "beat" to the MIDI score. You can indicate that we filled in the previous bar, and do something exciting like crash on the first beat, by supplying the -fill => $z argument, where $z is the fill we just played. Similarly, the -last => $y argument indicates that $y is the last beat we played, so that we can maintain "context sensitivity."

Unless specifically given a pattern to play with the -name argument, we try to play something different each time, so if the pattern is the same as the -last, or if there is no given pattern to play, another is chosen.

For -type => 'fill', we append a named fill to the MIDI score.

fill()

This is an alias to the beat method with -type => 'fill' added.

patterns()

$x = $d->patterns;
$x = $d->patterns('rock_1');
@x = $d->patterns(paraflamaramadiddle => \&code, 'foo fill' => \&foo_fill);

Return or set the code references to the named patterns. If no argument is given, all the known patterns are returned.

write()

$x = $d->write;
$x = $d->write('Buddy-Rich.mid');

This is an alias for "write_score" in MIDI::Simple but with unimaginably intelligent bits. It returns the name of the written file if successful. If no filename is given, we use the preset -file attribute.

KIT ACCESS

kit()

$x = $d->kit;
$x = $d->kit('snare');
@x = $d->kit( clapsnare => ['Handclap','Electric Snare'],
              kickstick => ['Bass Drum 1','Side Stick']);
@x = $d->kit('clapsnare');

Return or set part or all of the percussion set.

hhat()

$x = $d->hhat;
$x = $d->hhat('Cabasa','Maracas','Claves');

Strike or set the "hhat" patches. By default, these are the Closed Hi-Hat, Open Hi-Hat and the Pedal Hi-Hat.

crash()

$x = $d->crash;
$x = $d->crash(@crashes);

Strike or set the "crash" patches. By default, these are the Chinese Cymbal, Crash Cymbal 1, Crash Cymbal 2 and the Splash Cymbal.

ride()

$x = $d->ride;
$x = $d->ride(@rides);

Strike or set the "ride" patches. By default, these are the Ride Bell, Ride Cymbal 1 and the Ride Cymbal 2.

tom()

$x = $d->tom;
$x = $d->tom('Low Conga','Mute Hi Conga','Open Hi Conga');

Strike or set the "tom" patches. By default, these are the High Tom, Hi-Mid Tom, etc.

kick()

$x = $d->kick;
$x = $d->kick('Bass Drum 1');

Strike or set the "kick" patch. By default, this is the Acoustic Bass Drum.

tick()

$x = $d->tick;
$x = $d->tick('Mute Triangle');

Strike or set the "tick" patch. By default, this is the Closed Hi-Hat.

snare()

$x = $d->snare;
$x = $d->snare('Electric Snare');

Strike or set the "snare" patches. By default, this is the Acoustic Snare.

backbeat()

$x = $d->backbeat;
$x = $d->backbeat('Bass Drum 1','Side Stick');

Strike or set the "backbeat" patches. By default, these are the predefined kick and snare patches.

CONVENIENCE METHODS

These are meant to avoid literal strings and the need to remember and type the relevant MIDI variables.

WHOLE

$x = $d->WHOLE;

Return 'wn'.

HALF

Return 'hn'.

QUARTER

Return 'qn'.

EIGHTH

Return 'en'.

SIXTEENTH

Return 'sn'.

_p2n()

Return %MIDI::percussion2notenum a la "GOODIES" in MIDI.

_n2p()

Return the inverse: %MIDI::notenum2percussion.

_default_patterns()

_default_kit()

TO DO

* It don't mean a thing if it ain't got that swing. (That is, make a <MIDI::Simple::Drummer::Jazz> package.)

* Add 32nd and 64th durations to %MIDI::Simple::Length.

* Comprehend time signature via beat construction and keep a "running clock/total" to know where we are in time, at all times.

* Intelligently modulate dynamics - "add nuance" like accent or crescendo, etc.

* Multi-track ASAP!

* Import patterns via "read_score" in MIDI::Simple?

* Leverage "from_drum_tab" in MIDI::Tab?

SEE ALSO

The eg/* and t/* files, that come with this distribution.

The MIDI::Simple::Drummer::* style package(s).

MIDI::Simple itself.

http://maps.google.com/maps?q=mike+avery+joplin - my drum teacher.

AUTHOR AND COPYRIGHT

Gene Boggs <gene@cpan.org>

Copyright 2010, Gene Boggs, All Rights Reserved.

LICENSE

This program is free software; you can redistribute or modify it under the same terms as Perl itself.