Struct Score 

pub struct Score { /* private fields */ }

Describes a full Score

Implementations

impl Score

pub fn new<S: ToString>( name: S, tempo: Tempo, metadata: Option<Metadata>, ) -> Score

Returns a new empty Score from the given arguments

Arguments

• name - Title of the Score
• tempo - Tempo of the Score
• Metadata - Optional information

Examples found in repository

examples/praeludium_no1_single_phrase.rs (lines 21-30)

fn praeludium() -> Result<Score> {
    let mut part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(phrase()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_multi_phrase.rs (lines 33-42)

fn praeludium() -> Result<Score> {
    let mut part: Part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(right_hand()?, 0.);
    part.add_phrase(left_hand_high_note()?, 0.);
    part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_organ_piano.rs (lines 30-39)

fn praeludium() -> Result<Score> {
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    let mut organ_part = Part::new(Instrument::ChurchOrgan);

    piano_part.add_phrase(right_hand()?, 0.);
    organ_part.add_phrase(left_hand_high_note()?, 0.);
    organ_part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(piano_part);
    score.add_part(organ_part);
    Ok(score)
}

examples/scales_example.rs (line 26)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
    let s = Scale::new(
        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
        ScaleMode::Aeolian,
    );

    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase, 0.);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("scale_example.mid")?)?;
    Ok(())
}

examples/readme_example.rs (line 40)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
    // with crotchets, at MezzoForte volume
    let mut phrase_to_repeat = Phrase::new();
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);

    // Create a Strings part that plays the phrase from beat 0.5
    // (at the same time as the piano but shifted half a beat)
    let mut violins_part = Part::new(Instrument::StringEnsemble1);
    violins_part.add_phrase(phrase_to_repeat, 0.5);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);
    score.add_part(violins_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("readme_example.mid")?)?;
    Ok(())
}

pub fn add_part(&mut self, part: Part)

Adds a Part to the Score. Warning: q Score can contain unlimited Parts but if exporting to Standard MIDI File, any Score with more than 16 Parts will fail because MIDI only supports 16 channels.

Examples found in repository

examples/praeludium_no1_single_phrase.rs (line 31)

fn praeludium() -> Result<Score> {
    let mut part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(phrase()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_multi_phrase.rs (line 43)

fn praeludium() -> Result<Score> {
    let mut part: Part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(right_hand()?, 0.);
    part.add_phrase(left_hand_high_note()?, 0.);
    part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_organ_piano.rs (line 40)

fn praeludium() -> Result<Score> {
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    let mut organ_part = Part::new(Instrument::ChurchOrgan);

    piano_part.add_phrase(right_hand()?, 0.);
    organ_part.add_phrase(left_hand_high_note()?, 0.);
    organ_part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(piano_part);
    score.add_part(organ_part);
    Ok(score)
}

examples/scales_example.rs (line 27)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
    let s = Scale::new(
        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
        ScaleMode::Aeolian,
    );

    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase, 0.);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("scale_example.mid")?)?;
    Ok(())
}

examples/readme_example.rs (line 41)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
    // with crotchets, at MezzoForte volume
    let mut phrase_to_repeat = Phrase::new();
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);

    // Create a Strings part that plays the phrase from beat 0.5
    // (at the same time as the piano but shifted half a beat)
    let mut violins_part = Part::new(Instrument::StringEnsemble1);
    violins_part.add_phrase(phrase_to_repeat, 0.5);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);
    score.add_part(violins_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("readme_example.mid")?)?;
    Ok(())
}

pub fn set_tempo(&mut self, tempo: u32) -> Result<()>

Modifies the tempo of the Score

Errors

Returns ScoreError::InvalidTempo if tempo is 0

pub fn write_midi_file<W: Write>(&self, w: W) -> Result<()>

Examples found in repository

examples/praeludium_no1_organ_piano.rs (line 11)

fn main() {
    let score = praeludium().unwrap();
    let out_file = File::create("praeludium_piano_organ.mid").unwrap();
    score.write_midi_file(out_file).unwrap()
}

examples/praeludium_no1_multi_phrase.rs (line 16)

fn main() {
    let score = praeludium().unwrap();
    let out_file = File::create("praeludium_multi_phrase.mid").unwrap();
    score.write_midi_file(out_file).unwrap()
}

examples/praeludium_no1_single_phrase.rs (line 11)

fn main() {
    let score = praeludium().unwrap();
    let out_file = File::create("praeludium_single_phrase.mid").unwrap();
    score.write_midi_file(out_file).unwrap()
}

examples/scales_example.rs (line 30)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
    let s = Scale::new(
        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
        ScaleMode::Aeolian,
    );

    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase, 0.);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("scale_example.mid")?)?;
    Ok(())
}

examples/readme_example.rs (line 45)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
    // with crotchets, at MezzoForte volume
    let mut phrase_to_repeat = Phrase::new();
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);

    // Create a Strings part that plays the phrase from beat 0.5
    // (at the same time as the piano but shifted half a beat)
    let mut violins_part = Part::new(Instrument::StringEnsemble1);
    violins_part.add_phrase(phrase_to_repeat, 0.5);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);
    score.add_part(violins_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("readme_example.mid")?)?;
    Ok(())
}

pub fn name(&self) -> &str

Returns the title of the Score

pub fn parts(&self) -> &[Part]

Returns the Parts of the Score

pub fn tempo(&self) -> u32

Returns the tempo of the Score

pub fn metadata(&self) -> Option<&Metadata>

Returns the metadata

pub fn duration(&self) -> f64

Trait Implementations

impl Clone for Score

fn clone(&self) -> Score

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Score

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Score

fn default() -> Score

Returns the “default value” for a type.

impl PartialEq for Score

fn eq(&self, other: &Score) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> TryFrom<&'a Score> for Smf<'a>

fn try_from(score: &'a Score) -> Result<Smf<'a>>

Converts a Score into a Standard MIDI File (midly::Smf)

Arguments

• score - Score to convert

Errors

Returns ToMidiConversionError TODO: complete errors description

type Error = Error

The type returned in the event of a conversion error.

impl StructuralPartialEq for Score