# use to send patches, always empty for released version:
# include separator: ".postfix", "-pl" makes rpm barf
-TOPLEVEL_MY_PATCH_LEVEL = .jcn1
+TOPLEVEL_MY_PATCH_LEVEL = .jcn4
+pl 75.jcn4
+ - midi output, notes only
+
+pl 75.jcn3
+ - working midi output -- hacked
+
+pl 75.jcn2
+ - doze compile, mingw32 configure (still triggers gcc ico)
+
pl 75.jcn1
- all of the above
[ enable-profiling compile with gprof support],
[profile_b=$enableval])
-AC_ARG_ENABLE(mingw32,
+AC_ARG_ENABLE(mingw-prefix,
[ mingw-prefix=DIR set the mingw32 directory (standalone windows32 exes)],
[MINGWPREFIX=$enableval],
[MINGWPREFIX=no])
Performer "Performer_group_performer"
\consists "Lyric_performer";
\consists "Note_performer";
+ \consists "Silent_performer";
}
}
}
}
\score{
- \melodic { \IImenuetto }
+ % huh? how to set id_str
+ \melodic{ \id "Melodic" "Cello"; \IImenuetto }
\paper{
unitspace= 9.0\mm ;% to get lily to use only three lines
geometric= 1.40;
# use to send patches, always empty for released version:
# include separator: ".postfix", "-pl" makes rpm barf
-MY_PATCH_LEVEL = .jcn1
+MY_PATCH_LEVEL = .jcn2
virtual void prepare(Moment);
virtual void process() {}
virtual void finish() {}
+ virtual void start() {}
protected:
virtual Global_translator *global_l() { return this; }
// Rhythmic_req * note_req_l_;
// Melodic_req* current_l_;
-// Moment off_mom_;
+ Moment off_mom_;
// Moment on_mom_;
};
virtual Translator* get_default_interpreter();
Translator * ancestor_l( int l = 1 );
- int depth_i() const;
+ virtual int depth_i() const;
- void process_requests();
+ virtual Moment get_mom() const;
+
+ virtual void midi_output( Midi_stream* midi_stream_l );
+ virtual void process_requests();
+ virtual void set_track( Midi_def* midi_l, int& track_i_r );
private:
Pointer_list<Performer*> perf_p_list_;
Performer();
virtual ~Performer();
+ virtual void midi_output( Midi_stream* midi_stream_l_ );
void print() const;
virtual void process_requests();
+
+ virtual void set( Moment mom );
+ virtual void set_track( Midi_def* midi_l, int& track_i_r );
+
virtual bool try_request( Request* req_l );
protected:
virtual void do_print() const;
+ virtual Moment get_mom() const;
virtual void play_event( Midi_item* l );
};
virtual Translator* ancestor_l( int l );
virtual int depth_i() const;
- virtual void play_event( Midi_item* l );
+ virtual void finish();
+ virtual Moment get_mom() const;
virtual void prepare( Moment mom );
virtual void process();
+ virtual void set_score( Score* score_l );
+ virtual void start();
private:
+ void header();
+
+ Midi_def* midi_l_;
Midi_stream* midi_stream_p_;
Moment prev_mom_;
Moment now_mom_;
--- /dev/null
+/*
+ silent-performer.hh -- declare Silent_performer
+
+ (c) 1996, 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+ Jan Nieuwenhuizen <jan@digicash.com>
+ */
+
+#ifndef SILENT_PERFORMER_HH
+#define SILENT_PERFORMER_HH
+
+#include "performer.hh"
+
+/**
+*/
+
+class Silent_performer : public Performer {
+public:
+ NAME_MEMBERS();
+
+ Silent_performer();
+ ~Silent_performer();
+
+ virtual bool try_request( Request *req_l ) ;
+};
+
+#endif // SILENT_PERFORMER_HH
String instrument_str();
protected:
+ virtual void midi_output( Midi_stream* midi_stream_l_ );
virtual void play_event( Midi_item* l );
+ virtual void set_track( Midi_def* midi_l, int& track_i_r );
private:
- int midi_track_i_;
+ void header();
+
+ Midi_def* midi_l_;
+ Moment midi_mom_;
+ int track_i_;
+ Midi_track* midi_track_p_;
};
#endif // STAFF_PERFORMER_HH
-/*
- midioutput.cc -- implement Midi_output
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>, Jan Nieuwenhuizen <jan@digicash.com>
-*/
-
-#if 0
-#include "time.h"
-#include "main.hh"
-#include "source.hh"
-#include "proto.hh"
-#include "plist.hh"
-#include "string.hh"
-#include "string-convert.hh"
-#include "debug.hh"
-#include "score.hh"
-#include "main.hh"
-#include "midi-stream.hh"
-#include "midi-def.hh"
-#include "midi-output.hh"
-#include "midi-walker.hh"
-#include "midi-item.hh"
-#include "staff-column.hh"
-#include "musical-request.hh"
-#include "p-score.hh"
-
-Midi_output::Midi_output(Score* score_l, Midi_def* midi_l )
-{
- midi_l_ = midi_l;
- score_l_ = score_l;
-
- Midi_stream midi_stream(midi_l->outfile_str_,
- // don-t forget: extra track 0 for tempo/copyright stuff...
- score_l_->staffs_.size() + 1,
- 384 );
- midi_stream_l_ = &midi_stream;
-
- header();
- staffs();
-}
-
-void
-Midi_output::do_staff(Staff*st_l,int track_i)
-{
- Midi_track midi_track( track_i );
-
- // set track name
- Midi_text track_name( Midi_text::TRACK_NAME, "Track " + String_convert::i2dec_str( track_i, 0, '0' ) );
- midi_track.add( Moment( 0 ), &track_name );
-
- // set instrument :-)
- Midi_text instrument_name( Midi_text::INSTRUMENT_NAME, "piano" );
- midi_track.add( Moment( 0 ), &instrument_name );
-
- Midi_tempo midi_tempo( midi_l_->get_tempo_i( Moment( 1, 4 ) ) );
- midi_track.add( Moment( 0 ), &midi_tempo );
-
- for (Midi_walker w (st_l, &midi_track); w.ok(); w++)
- w.do_process_requests();
-
- *midi_stream_l_ << midi_track;
-}
-
-void
-Midi_output::header()
-{
- Midi_track midi_track( 0 );
-
- time_t t = time( 0 );
-
- // perhaps multiple text events?
- String str = String( "Creator: " ) + get_version_str() + "\n";
-
- Midi_text creator( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &creator );
-
- str = "Generated, at ";
- str += ctime( &t );
- str = str.left_str( str.length_i() - 1 );
- str += ",\n";
- Midi_text generate( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &generate );
-
-#if 0 // TODO!
- Source_file* sourcefile_l = source_l_g->sourcefile_l( score_l_->defined_ch_C_ );
- if ( sourcefile_l ) {
- str += "from musical definition: "
- + sourcefile_l->file_line_no_str(score_l_->defined_ch_C_);
-
- }
-#endif
- Midi_text from( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &from );
-
- // set track name
- Midi_text track_name( Midi_text::TRACK_NAME, "Track " + String_convert::i2dec_str( 0, 0, '0' ) );
- midi_track.add( Moment( 0 ), &track_name );
-
- // ugh, to please lily when reparsing mi2mu output.
- // lily currently barfs when no meter present.
- /* are you sure? init is to 4/4 HWN */
- Midi_time midi_time( 4, 4, 18 );
- midi_track.add( Moment( 0.0 ), &midi_time );
-
- *midi_stream_l_ << midi_track;
-}
-
-void
-Midi_output::staffs()
-{
- int track_i = 1;
- for (iter_top(score_l_->staffs_,i); i.ok(); i++)
- do_staff(i, track_i++);
-}
-
-#endif
--- /dev/null
+/*
+ midi-walker.cc -- implement Midi_walker
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>, Jan Nieuwenhuizen <jan@digicash.com>
+
+ TODO
+
+ Ideally this should also use a register system, to process slurs,
+ dynamics, etc.
+
+*/
+
+/* reincluded for code jatting */
+#if 0
+
+#include "command-request.hh"
+#include "musical-request.hh"
+#include "p-score.hh"
+#include "staff.hh"
+#include "midi-walker.hh"
+#include "midi-item.hh"
+#include "midi-stream.hh"
+#include "debug.hh"
+#include "staff-column.hh"
+
+Midi_walker::Midi_walker(Staff *st_l, Midi_track* track_l)
+ : PCursor<Staff_column*>(st_l->cols_)
+{
+ track_l_ = track_l;
+ last_moment_= 0;
+}
+
+/**
+ output notestop events for all notes which end before #max_moment#
+ */
+void
+Midi_walker::do_stop_notes(Moment max_moment)
+{
+ while (stop_notes.size() && stop_notes.front().key <= max_moment) {
+ Note_event ent=stop_notes.get();
+ if (ent.ignore_b_)
+ continue;
+
+ Moment stop_moment = ent.key;
+ Melodic_req * req_l = ent.val;
+
+ Midi_note note(req_l, track_l_->number_i_, false);
+ output_event(note, stop_moment);
+ }
+}
+/**
+ Find out if start_note event is needed, and do it if needed.
+ */
+void
+Midi_walker::do_start_note(Note_req*note_l)
+{
+ Moment stop = note_l->duration() + ptr()->when();
+ for(int i=0; i < stop_notes.size(); i++) {
+ if (stop_notes[i].val->melodic()->pitch() ==
+ note_l->pitch()) {
+ if ( stop_notes[i].key < stop){
+ stop_notes[i].ignore_b_=true;
+ }
+ else
+ return; // skip the stop note
+ }
+ }
+ Note_event e;
+ e.val = note_l;
+ e.key = stop;
+
+ stop_notes.insert(e);
+
+ Midi_note note(note_l, track_l_->number_i_, true);
+ output_event(note, ptr()->when());
+}
+
+
+/** advance the track to #now#, output the item, and adjust current
+ "moment". */
+void
+Midi_walker::output_event(Midi_item &i, Moment now)
+{
+ Moment delta_t = now - last_moment_ ;
+ last_moment_ += delta_t;
+ track_l_->add(delta_t, &i );
+}
+
+void
+Midi_walker::process_requests()
+{
+ do_stop_notes(ptr()->when());
+
+ for ( int i = 0; i < ptr()->commandreq_l_arr_.size(); i++ ) {
+ Command_req *c_l = ptr()->commandreq_l_arr_[i]->command();
+ Meter_change_req* meter_l = c_l->meterchange();
+ if ( meter_l )
+ output_event( Midi_time( meter_l->beats_i_, meter_l->one_beat_i_, 18 ), ptr()->when() );
+ Key_change_req* key_l = c_l->keychange();
+ if ( key_l ) {
+ int sharps_i = key_l->sharps_i();
+ int flats_i = key_l->flats_i();
+ // midi cannot handle non-conventional keys
+ if ( !( flats_i && sharps_i ) )
+ output_event( Midi_key( sharps_i - flats_i, key_l->minor_b() ), ptr()->when() );
+ }
+ }
+
+ for ( int i = 0; i < ptr()->musicalreq_l_arr_.size(); i++ ) {
+ Musical_req *m = ptr()->musicalreq_l_arr_[i]->musical();
+ if (!m)
+ return;
+ Rhythmic_req *n = m->rhythmic();
+ if ( !n)
+ continue;
+ Note_req * note_l = n->note();
+ if (!note_l)
+ continue;
+ do_start_note(note_l);
+ }
+}
+
+Midi_walker::~Midi_walker()
+{
+ do_stop_notes( last_moment_ + Moment(10,1)); // ugh
+}
+
+
+int
+compare(Note_event const&e1, Note_event const&e2)
+{
+ return sign(e1.key - e2.key);
+}
+
+#endif
/*
note-performer.cc -- implement Note_performer
- (c) 1996, 1997 Han-Wen Nienhuys <hanwen@stack.nl>
- Jan Nieuwenhuizen <jan@digicash.com>
+ (c) 1996, 1997 Jan Nieuwenhuizen <jan@digicash.com>
*/
#include "note-performer.hh"
Note_performer::Note_performer()
{
- // is this what we want?
- // or do we need to cache/keep note until it has ended?
note_req_l_ = 0;
+ off_mom_ = 0;
}
Note_performer::~Note_performer()
//Midi_note( Melodic_req* melreq_l, int channel_i, bool on_bo )
// this is _really_ braindead, but it generates some output
- if ( note_req_l_ && note_req_l_->melodic() ) {
- Midi_note n( note_req_l_->melodic(), 0, true );
+ if ( !note_req_l_ || !note_req_l_->melodic() || !note_req_l_->rhythmic() )
+ return;
+
+ // ugh, need to know channel (===track===staff) too
+ int channel_i = 0;
+ Moment mom = get_mom();
+ if ( !off_mom_ ) { // start note
+ off_mom_ = mom + note_req_l_->duration();
+ Midi_note n( note_req_l_->melodic(), channel_i, true );
play_event( &n );
}
- note_req_l_ = 0;
+ else if ( mom == off_mom_ ) {
+ Midi_note n( note_req_l_->melodic(), channel_i, false );
+ play_event( &n );
+ note_req_l_ = 0;
+ off_mom_ = 0;
+ }
}
bool
// if (req_l->musical() && (req_l->musical()->note() || req_l->musical()->rest()))
// note_req_l_ = req_l->musical()->rhythmic();
if ( req_l->musical() && req_l->musical()->note() )
+// huh?
note_req_l_ = req_l->musical()->melodic();
else
return false;
#include "break.hh"
#include "p-col.hh"
+PScore::PScore(Paper_def*p)
+{
+ paper_l_ = p;
+ super_elem_l_ = new Super_elem;
+ typeset_element(super_elem_l_);
+}
+
+PScore::~PScore()
+{
+ super_elem_l_->unlink_all();
+}
+
void
PScore::typeset_element(Score_elem * elem_p)
{
cols.bottom().add(p);
}
-PScore::PScore(Paper_def*p)
-{
- paper_l_ = p;
- super_elem_l_ = new Super_elem;
- typeset_element(super_elem_l_);
-}
-
void
PScore::output(Tex_stream &ts)
{
}
-PScore::~PScore()
-{
- super_elem_l_->unlink_all();
-}
-
void
PScore::OK()const
{
return perf_p->get_default_interpreter();
}
+Moment
+Performer_group_performer::get_mom() const
+{
+ Moment mom = Performer::get_mom();
+
+ for ( int i = 0; i < nongroup_l_arr_.size(); i++ )
+ nongroup_l_arr_[ i ]->set( mom );
+
+ return mom;
+}
+
bool
Performer_group_performer::is_bottom_performer_b() const
{
return !itrans_l_->get_default_itrans_l();
}
+void
+Performer_group_performer::midi_output( Midi_stream* midi_stream_l )
+{
+ for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ i->midi_output( midi_stream_l );
+}
+
void
Performer_group_performer::process_requests()
{
- PCursor<Performer*> i( perf_p_list_.top() );
- while( i.ok() ) {
- Performer* perf_l = i++;
- perf_l->process_requests();
- }
+ for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ i->process_requests();
+}
+
+void
+Performer_group_performer::set_track( Midi_def* midi_l, int& track_i_r )
+{
+ for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ i->set_track( midi_l, track_i_r );
}
bool
hebbes_b = daddy_perf_l_->try_request(req_l);
return hebbes_b ;
}
+
{
}
+Moment
+Performer::get_mom() const
+{
+ return daddy_perf_l_->get_mom();
+}
+
+void
+Performer::midi_output( Midi_stream* )
+{
+}
+
void
Performer::play_event( Midi_item* l )
{
{
}
+void
+Performer::set( Moment )
+{
+}
+
+void
+Performer::set_track( Midi_def*, int& )
+{
+}
+
bool
Performer::try_request( Request* req_l )
{
/*
score-performer.cc -- implement Score_performer
- (c) 1996, 1997 Han-Wen Nienhuys <hanwen@stack.nl>
- Jan Nieuwenhuizen <jan@digicash.com>
+ (c) 1996, 1997 Jan Nieuwenhuizen <jan@digicash.com>
*/
+#include <time.h>
#include "score-performer.hh"
#include "input-translator.hh"
+#include "midi-def.hh"
#include "midi-item.hh"
#include "midi-stream.hh"
#include "string-convert.hh"
#include "debug.hh"
+#include "main.hh"
+#include "score.hh"
+#include "source-file.hh"
+#include "source.hh"
IMPLEMENT_IS_TYPE_B1(Score_performer,Performer_group_performer);
IMPLEMENT_STATIC_NAME(Score_performer);
Score_performer::Score_performer()
{
- // not so much ugh, as [todo]
- *mlog << "MIDI output to " << "lelie.midi" << " ...\n";
- midi_stream_p_ = new Midi_stream( "lelie.midi",
- // don-t forget: extra track 0 for tempo/copyright stuff...
- //score_l_->staffs_.size() + 1,
- 1,
- 384 );
+ midi_stream_p_ = 0;
+ midi_l_ = 0;
}
Score_performer::~Score_performer()
return Global_translator::depth_i();
}
-void
-Score_performer::play_event( Midi_item* l )
+void
+Score_performer::finish()
+{
+ *mlog << "MIDI output to " << midi_l_->outfile_str_ << " ..." << endl;
+ *mlog << "tracks: ";
+ header();
+ Performer_group_performer::midi_output( midi_stream_p_ );
+ *mlog << endl;
+}
+
+Moment
+Score_performer::get_mom() const
{
-// file_p_->output( l );
-// cerr << String_convert::bin2hex_str( l->str() );
- // this should be done at staff level,
- // cached per staff probably.
- // but it generates output...
- *midi_stream_p_ << *l;
+ return now_mom_;
+}
+
+void
+Score_performer::header()
+{
+ int track_i = 0;
+ Midi_track midi_track( track_i );
+
+ time_t t = time( 0 );
+
+ // perhaps multiple text events?
+ String str = String( "Creator: " ) + get_version_str() + "\n";
+
+ Midi_text creator( Midi_text::TEXT, str );
+ midi_track.add( Moment( 0 ), &creator );
+
+ str = "Generated, at ";
+ str += ctime( &t );
+ str = str.left_str( str.length_i() - 1 );
+ str += ",\n";
+ Midi_text generate( Midi_text::TEXT, str );
+ midi_track.add( Moment( 0 ), &generate );
+
+ str = "from musical definition: ";
+#if 0
+ Source_file* sourcefile_l = source_l_g->sourcefile_l( score_l_->defined_ch_C_ );
+ if ( sourcefile_l )
+ str += sourcefile_l->name_str();
+#elif 1
+ str += score_l_->location_str();
+#else
+ str += score_l_->
+#endif
+ Midi_text from( Midi_text::TEXT, str );
+ midi_track.add( Moment( 0 ), &from );
+
+ // set track name
+ Midi_text track_name( Midi_text::TRACK_NAME, "Track " + String_convert::i2dec_str( 0, 0, '0' ) );
+ midi_track.add( Moment( 0 ), &track_name );
+
+ // ugh, to please lily when reparsing mi2mu output.
+ // lily currently barfs when no meter present.
+ /* are you sure? init is to 4/4 HWN */
+ Midi_time midi_time( 4, 4, 18 );
+ midi_track.add( Moment( 0.0 ), &midi_time );
+
+ *mlog << "[" << track_i << "]";
+ *midi_stream_p_ << midi_track;
}
void
prev_mom_ = now_mom_;
}
+void
+Score_performer::set_score( Score* score_l )
+{
+ /*
+ why's there no start() when there's a finish()?
+ let's misuse this for start()
+ */
+ Global_translator::set_score( score_l );
+ midi_l_ = score_l->midi_p_;
+}
+
+void
+Score_performer::start()
+{
+ int track_i = 1;
+ Performer_group_performer::set_track( midi_l_, track_i );
+
+ if ( midi_l_->outfile_str_ == "" )
+ midi_l_->outfile_str_ = default_out_fn + ".midi";
+
+ midi_stream_p_ = new Midi_stream( midi_l_->outfile_str_, track_i, 384 );
+}
+
extern String default_out_fn;
+Score::Score()
+{
+ pscore_p_=0;
+ paper_p_ = 0;
+ midi_p_ = 0;
+ errorlevel_i_ = 0;
+}
+
Score::Score(Score const &s)
{
assert(!pscore_p_);
paper_p_ = new Paper_def(*s.paper_p_);
}
+Score::~Score()
+{
+ delete music_p_;
+ delete pscore_p_;
+ delete paper_p_;
+ delete midi_p_;
+}
+
void
Score::run_translator(Global_translator * trans_l)
{
trans_l);
iter->construct_children();
+ trans_l->start();
while ( iter->ok() || trans_l->moments_left_i() ) {
Moment w = INFTY;
if (iter->ok() ) {
trans_l->finish();
}
-
void
Score::process()
{
void
Score::midi()
{
- if (!midi_p_)
+ if ( !midi_p_ )
return;
- *mlog << "\nCreating elements ..." << endl; //flush;
-// pscore_p_ = new PScore(paper_p_);
+ *mlog << "\nCreating elements ..." << flush;
Global_translator* score_trans= midi_p_->get_global_translator_p();
run_translator( score_trans );
if( errorlevel_i_){
// should we? hampers debugging.
- warning("Errors found, /*not processing score*/");
+ warning( "Errors found, /*not processing score*/" );
// return;
}
print();
*mlog << endl;
-// pscore_p_->process();
-
- // output
- midi_output();
}
void
#endif
}
-Score::Score()
-{
- pscore_p_=0;
- paper_p_ = 0;
- midi_p_ = 0;
- errorlevel_i_ = 0;
-}
-
-Score::~Score()
-{
- delete music_p_;
- delete pscore_p_;
- delete paper_p_;
- delete midi_p_;
-}
-
void
Score::paper_output()
{
--- /dev/null
+/*
+ silent-performer.cc -- implement Silent_performer
+
+ (c) 1996, 1997 Jan Nieuwenhuizen <jan@digicash.com>
+ */
+
+#include "silent-performer.hh"
+#include "translator.hh"
+#include "input-translator.hh"
+#include "command-request.hh"
+#include "musical-request.hh"
+#include "debug.hh"
+
+IMPLEMENT_IS_TYPE_B1(Silent_performer,Performer);
+IMPLEMENT_STATIC_NAME(Silent_performer);
+ADD_THIS_PERFORMER(Silent_performer);
+
+Silent_performer::Silent_performer()
+{
+}
+
+Silent_performer::~Silent_performer()
+{
+}
+
+bool
+Silent_performer::try_request( Request* req_l )
+{
+ return true;
+#if 0
+ Command_req* com_l = req_l->command();
+ Musical_req* mus_l = req_l->musical();
+
+ if ( com_l ) {
+ if ( com_l->bar() )
+ return true;
+
+ if ( com_l->barcheck() )
+ return true;
+ }
+
+ if ( mus_l ) {
+ if ( mus_l->beam() )
+ return true;
+
+ if( mus_l->rest() )
+ return true;
+
+ if( mus_l->slur() )
+ return true;
+
+ if ( mus_l->stem() )
+ return true;
+
+ if ( mus_l->tie() )
+ return true;
+ }
+
+ return false;
+#endif
+}
+
/*
staff-performer.cc -- implement Staff_performer
- (c) 1996, 1997 Han-Wen Nienhuys <hanwen@stack.nl>
- Jan Nieuwenhuizen <jan@digicash.com>
+ (c) 1996, 1997 Jan Nieuwenhuizen <jan@digicash.com>
*/
#include "translator.hh"
#include "input-translator.hh"
#include "debug.hh"
+#include "midi-def.hh"
+#include "midi-item.hh"
+#include "midi-stream.hh"
+#include "string.hh"
+#include "string-convert.hh"
IMPLEMENT_STATIC_NAME(Staff_performer);
IMPLEMENT_IS_TYPE_B1(Staff_performer,Performer_group_performer);
Staff_performer::Staff_performer()
{
+ midi_mom_ = 0;
+ track_i_ = 0;
+ midi_track_p_ = 0;
}
Staff_performer::~Staff_performer()
{
+ delete midi_track_p_;
+}
+
+void
+Staff_performer::header()
+{
+ // set track name
+ Midi_text track_name( Midi_text::TRACK_NAME, "Track " + String_convert::i2dec_str( track_i_, 0, '0' ) );
+ midi_track_p_->add( Moment( 0 ), &track_name );
+
+ // set instrument :-)
+ Midi_text instrument_name( Midi_text::INSTRUMENT_NAME, instrument_str() );
+ midi_track_p_->add( Moment( 0 ), &instrument_name );
+
+ Midi_tempo midi_tempo( midi_l_->get_tempo_i( Moment( 1, 4 ) ) );
+ midi_track_p_->add( Moment( 0 ), &midi_tempo );
}
String
return Translator::id_str_;
}
+void
+Staff_performer::midi_output( Midi_stream* midi_stream_l )
+{
+ *mlog << "[" << track_i_ << "]";
+ *midi_stream_l << *midi_track_p_;
+}
+
void
Staff_performer::play_event( Midi_item* l )
{
-// l.track_i_ = midi_track_i_;
- Performer::play_event( l );
+ Moment mom = get_mom();
+ Moment delta_t = mom - midi_mom_ ;
+ midi_mom_ += delta_t;
+ midi_track_p_->add( delta_t, l );
+}
+
+void
+Staff_performer::set_track( Midi_def* midi_l, int& track_i_r )
+{
+ midi_l_ = midi_l;
+ track_i_ = track_i_r++;
+ midi_track_p_ = new Midi_track( track_i_ );
+ header();
}
#endif
// arrays are 20% faster, but we have no Pointer_array yet
-#define MVOICE_LIST // does this work?
-#define MEVENT_LIST
+#define MEVENT_LIST // does this work?
+#define MVOICE_LIST
#define TCOL_LIST
#include "string.hh"
#include "plist.hh"
#include "plist.tcc"
-//IPL_instantiate(Midi_event);
+#ifdef MEVENT_LIST
+IPL_instantiate(Midi_event);
+#endif
+
IPL_instantiate(Midi_track);
-// PL_instantiate(Midi_voice);
+
+#ifdef MVOICE_LIST
+PL_instantiate(Midi_voice);
+#endif
+
IPL_instantiate(Midi_voice);
-//IPL_instantiate(Track_column);
+
+#ifdef TCOL_LIST
+IPL_instantiate(Track_column);
+#endif
projects / lilypond.git / commitdiff