X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fperformance.cc;h=9f840efd2524eedc28e7204a13d5c5f47d97a958;hb=90e4d7057f3857da049dfda3d130017d4719bd6b;hp=695bb399f7a00cc15be7a9e6831e877521016a46;hpb=b37e3f652677ae0298423db9fa0e552e5fce0c92;p=lilypond.git diff --git a/lily/performance.cc b/lily/performance.cc index 695bb399f7..9f840efd25 100644 --- a/lily/performance.cc +++ b/lily/performance.cc @@ -1,9 +1,20 @@ /* - performance.cc -- implement Performance + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1997--2015 Jan Nieuwenhuizen - (c) 1997--2006 Jan Nieuwenhuizen + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ #include "performance.hh" @@ -12,158 +23,113 @@ using namespace std; #include "audio-column.hh" +#include "audio-item.hh" #include "audio-staff.hh" #include "file-name.hh" #include "international.hh" #include "lily-version.hh" #include "main.hh" -#include "midi-item.hh" +#include "midi-chunk.hh" #include "midi-stream.hh" #include "score.hh" #include "string-convert.hh" #include "warn.hh" -#include "killing-cons.tcc" - -Performance::Performance () +Performance::Performance (bool ports) + : midi_ (0), + ports_ (ports), + header_ (SCM_EOL) { - midi_ = 0; - audio_element_list_ = 0; } Performance::~Performance () { - delete audio_element_list_; + junk_pointers (audio_elements_); } void -Performance::output (Midi_stream &midi_stream) +Performance::derived_mark () const { - int tracks_i = audio_staffs_.size () + 1; - - // ugh - int clocks_per_4_i = 384; + scm_gc_mark (header_); +} - midi_stream << Midi_header (1, tracks_i, clocks_per_4_i); - output_header_track (midi_stream); - message (_ ("Track...") + " "); - int channel = 0; - for (int i = 0; i < audio_staffs_.size (); i++) - { - Audio_staff *s = audio_staffs_[i]; - if (be_verbose_global) - progress_indication ("[" + to_string (i)); - - /* - MIDI players tend to ignore instrument settings on - channel 10, the percussion channel by default. - */ - if (channel % 16 == 9) - channel++; - - /* - Huh? Why does each staff also have a separate channel? We - should map channels to voices, not staves. --hwn. - */ - if (s->channel_ < 0) - { - s->channel_ = channel % 16; - if (channel > 15) - { - warning (_ ("MIDI channel wrapped around")); - warning (_ ("remapping modulo 16")); - } - } - - s->output (midi_stream, channel++); - if (be_verbose_global) - progress_indication ("]"); - } +SCM +Performance::get_header () const +{ + return header_; } void -Performance::output_header_track (Midi_stream &midi_stream) +Performance::set_header (SCM module) { - Midi_track midi_track; - - midi_track.channel_ = 9; - - // perhaps multiple text events? - std::string id_string; - std::string str = std::string (_ ("Creator: ")); - id_string = String_convert::pad_to (gnu_lilypond_version_string (), 30); - str += id_string; - - /* - This seems silly, but in fact the audio elements should - be generated elsewhere: not midi-specific. - */ - Audio_text creator_a (Audio_text::TEXT, str); - Midi_text creator (&creator_a); - midi_track.add (Moment (0), &creator); - - /* Better not translate this */ - str = "Generated automatically by: "; - str += id_string; - - Audio_text generate_a (Audio_text::TEXT, str); - Midi_text generate (&generate_a); - midi_track.add (Moment (0), &generate); - - str = _ ("at "); - time_t t (time (0)); - str += ctime (&t); - str = str.substr (0, str.length () - 1); - str = String_convert::pad_to (str, 60); - - Audio_text at_a (Audio_text::TEXT, str); - Midi_text at (&at_a); - midi_track.add (Moment (0), &at); - - // TODO: - // str = _f ("from musical definition: %s", origin_string_); - - Audio_text from_a (Audio_text::TEXT, str); - Midi_text from (&from_a); - midi_track.add (Moment (0), &from); + assert (ly_is_module (module)); + header_ = module; +} - Audio_text track_name_a (Audio_text::TRACK_NAME, "Track " - + String_convert::int2dec (0, 0, '0')); - Midi_text track_name (&track_name_a); +void +Performance::output (Midi_stream &midi_stream, + const string &performance_name) const +{ + int tracks_ = audio_staffs_.size (); - midi_track.add (Moment (0), &track_name); + midi_stream.write (Midi_header (1, tracks_, 384)); + debug_output (_ ("Track...") + " ", false); - // Some sequencers read track 0 last. - // Audio_tempo tempo_a (midi_->get_tempo (Moment (Rational (1, 4)))); - // Midi_tempo tempo (&tempo_a); - // midi_track.add (Moment (0), &tempo); + //Find the first Audio_item in the performance, so all staves start + //at the same tick. + Moment start_mom = 0; + for (vsize i = 0; i < audio_elements_.size (); i++) + if (Audio_item *item = dynamic_cast(audio_elements_[i])) + start_mom = min (start_mom, item->audio_column_->when ()); - midi_stream << midi_track; + for (vsize i = 0; i < audio_staffs_.size (); i++) + { + Audio_staff *s = audio_staffs_[i]; + if (Audio_control_track_staff *c = + dynamic_cast(s)) + { + // The control track, created by Control_track_performer, should + // contain a placeholder for the name of the MIDI sequence as its + // initial audio element. Fill in the name of the sequence to + // this element before outputting MIDI. + assert (!c->audio_items_.empty ()); + Audio_text *text = + dynamic_cast(c->audio_items_.front ()); + assert (text != 0); + assert (text->type_ == Audio_text::TRACK_NAME); + assert (text->text_string_ == "control track"); + text->text_string_ = performance_name; + } + debug_output ("[" + ::to_string (i), true); + s->output (midi_stream, i, ports_, moment_to_ticks (start_mom)); + debug_output ("]", false); + } } void Performance::add_element (Audio_element *p) { - if (Audio_staff *s = dynamic_cast (p)) - audio_staffs_.push (s); - audio_element_list_ = new Killing_cons (p, audio_element_list_); + audio_elements_.push_back (p); } void -Performance::write_output (std::string out) +Performance::write_output (string out, const string &performance_name) const { if (out == "-") out = "lelie.midi"; /* Maybe a bit crude, but we had this before */ File_name file_name (out); - file_name.ext_ = "midi"; out = file_name.to_string (); Midi_stream midi_stream (out); message (_f ("MIDI output to `%s'...", out)); - output (midi_stream); + output (midi_stream, performance_name); progress_indication ("\n"); } +void +Performance::process () +{ +}