]> git.donarmstrong.com Git - lilypond.git/commitdiff
lilypond-0.0.34
authorfred <fred>
Sun, 24 Mar 2002 19:33:13 +0000 (19:33 +0000)
committerfred <fred>
Sun, 24 Mar 2002 19:33:13 +0000 (19:33 +0000)
.dstreamrc
Documentation/README.pod
hdr/midioutput.hh [new file with mode: 0644]
input/midi.ly
input/wohltemperirt.ly
src/main.cc
src/midiitem.cc
src/midioutput.cc [new file with mode: 0644]
src/midiwalker.cc

index b2c6cfc5daf07796df2ce1a5e3eab78ed09b9994..0ae4806aca2d678d34e049ccccf3712c3db9089d 100644 (file)
@@ -38,7 +38,7 @@ Input_cursor          1
 Commands_at            1
 Input_command          1
 Time_description       1
-Melodic_req            1
+Melodic_req            0
 Midi_walker            0
 Stem_req               1
 Group_change_req       1
index a837d6a07096c6bd28c4ac9eef75885d8a1c40f6..7126e8edc115a10dd09a0c6082e65bb80bf89bd4 100644 (file)
@@ -120,6 +120,11 @@ broken systems.
 
 add F<FILE> to the search path for input files.
 
+
+=item B<-M,--midi>
+
+do midi output only
+
 =item B<-d,--debug>,
 
 Turn debugging info. LilyPond will read the file F<.dstreamrc>, which
diff --git a/hdr/midioutput.hh b/hdr/midioutput.hh
new file mode 100644 (file)
index 0000000..fed37fe
--- /dev/null
@@ -0,0 +1,19 @@
+/*
+  midioutput.hh -- declare Midi_output
+
+  source file of the LilyPond music typesetter
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef MIDIOUTPUT_HH
+#define MIDIOUTPUT_HH
+#include "pscore.hh"
+
+struct Midi_output {
+    Midi_stream*    midi_stream_l_;
+    Midi_output(Score* score_l, Midi_def* );
+    void do_staff(Staff*st_l, int count);
+};
+#endif // MIDIOUTPUT_HH
index c08b1bc348055fabe044a7765b90eb5d58ca3600..bdb0a48d3896af3cf4d4be6d5dffd9b35ec892e5 100644 (file)
@@ -1,12 +1,9 @@
 % midi.ly
 % test source for lilypond-s midi output
 
-
-% BUG: 2e noot van begeleiding bij g2 niet gespeeld.
-% BUG: rust (5e maat) niet gespeeld.
 melodie = music {
        $\clef\violin
-       c c | g g | a a | g2 | r2
+       c c | g g | a a | g2 
        f f | e e | d d8.( e16 | )c2 | % :|
        $
 }
@@ -15,7 +12,7 @@ begeleiding = music {
        $
        \clef \bass
        \octave{`}
-       c 'c | 'e 'c | 'f 'c | 'e 'c | r2
+       c 'c | 'e 'c | 'f 'c | 'e 'c 
        'd b | 'c a | f g | c2 | 
        $
 }
@@ -31,15 +28,8 @@ bass_staf = staff {
 }
 
 score {
-%      staff { mstaf }
-%      staff { bass_staf }
-%      paper { unitspace 2.5cm }
-       % in own audio {  } block iso score { } ?
-       % allow no score { } block ?
-
-       staff { midi music { melodie } }
-       staff { midi music { begeleiding } }
-%      staff { midi music { bla } }
+       staff { mstaf }
+       staff { bass_staf }
        midi {
                tempo 4:120
        }
index 1038169bab11b74e0f4622c529e58da734f5bc66..b5ea0f66542ab07a0ac2764359e8f9f8ee0d5a0e 100644 (file)
@@ -42,31 +42,32 @@ bassdux = music { $
        r |
        r |
        r |
-       r |
+       r1 |
        r8 [c16 B] [c8 G] [As c16 B] [c8 d] |
        [G c16 B] [c8 d] [F16 G] As4 [G16 F] | 
 $}
 
-basstaf = staff { melodic
-       music { bassdux }
-}
-
-score {
-       staff { melodic
+trebstaf =     staff { melodic
                % every "music {} " in a staff has its own "voicegroup"
                music { dux }
                music { comes }
                
        }
+
+basstaf = staff { melodic
+       music { bassdux }
+}
+
+score {
        staff { basstaf }
+       staff { trebstaf }
+       
        commands {
                meter {4*4}
                grouping {2*2}
                key {$bes es as$}
        }
-       staff { midi music { dux } }
-       staff { midi music { comes } }
-       staff { midi music { bassdux } }
+       paper {}
        midi {
                tempo 4:80
        }
index e100ec2884f21156d8b6b85eff4591142fdd65de..55a5129055fece4b9cdfcd598ce1a47f1e0f0496 100644 (file)
@@ -12,8 +12,8 @@
 #include "source.hh"
 
 Source source;
-Source* source_global_l = &source;
-
+Source* source_l_g = &source;
+bool only_midi = false;
 extern void parse_file(String,String);
 
 
@@ -26,6 +26,7 @@ long_option_init theopts[] = {
     0, "debug", 'd',
     1, "init", 'i',
     1, "include", 'I',
+    0, "midi", 'M',
     0,0,0
 };
 
@@ -39,11 +40,13 @@ help()
        "--debug, -d            enable debug output\n"
        "--init, -i             set init file\n"
         "--include, -I         add to file search path.\n"
+       "--midi, -M             midi output only\n"
        ;
     
 }
 
-void notice()
+void 
+notice()
 {
     cout <<
        "\n"
@@ -110,6 +113,9 @@ main (int argc, char **argv)
        case 'd':
            set_debug(true);
            break;
+       case 'M':
+           only_midi = true;
+           break;
        default:
            assert(false);
            break;
index e7d5ccc92f48556ba0a063af5799f1c4986b0717..b86eb95f1b09bbca1db49837906992544e9fbb32 100644 (file)
@@ -23,104 +23,111 @@ Midi_chunk::Midi_chunk()
 void
 Midi_chunk::add( String str )
 {
-       data_str_ += str;
+    data_str_ += str;
 }
 
 void
 Midi_chunk::set( String header_str, String data_str, String footer_str )
 {
-       data_str_ = data_str;
-       footer_str_ = footer_str;
-       header_str_ = header_str;
+    data_str_ = data_str;
+    footer_str_ = footer_str;
+    header_str_ = header_str;
 }
   
 String
 Midi_chunk::str()
 {
-       String str = header_str_;
-       String length_str = StringConversion::int2hex_str( data_str_.length_i() + footer_str_.length_i(), 8, '0' );
-       length_str = StringConversion::hex2bin_str( length_str );
-       str += length_str;
-       str += data_str_;
-       str += footer_str_;
-       return str;
+    String str = header_str_;
+    String length_str = StringConversion::int2hex_str( data_str_.length_i() + footer_str_.length_i(), 8, '0' );
+    length_str = StringConversion::hex2bin_str( length_str );
+    str += length_str;
+    str += data_str_;
+    str += footer_str_;
+    return str;
 }
 
 Midi_duration::Midi_duration( Real seconds_f )
 {
-       seconds_f_ = seconds_f;
+    seconds_f_ = seconds_f;
 }
 
 String
 Midi_duration::str()
 {
-       return String( "<duration: " ) + String( seconds_f_ ) + ">";
+    return String( "<duration: " ) + String( seconds_f_ ) + ">";
 }
 
 Midi_header::Midi_header( int format_i, int tracks_i, int tempo_i )
 {
-       String str;
+    String str;
        
-       String format_str = StringConversion::int2hex_str( format_i, 4, '0' );
-       str += StringConversion::hex2bin_str( format_str );
+    String format_str = StringConversion::int2hex_str( format_i, 4, '0' );
+    str += StringConversion::hex2bin_str( format_str );
        
-       String tracks_str = StringConversion::int2hex_str( tracks_i, 4, '0' );
-       str += StringConversion::hex2bin_str( tracks_str );
+    String tracks_str = StringConversion::int2hex_str( tracks_i, 4, '0' );
+    str += StringConversion::hex2bin_str( tracks_str );
 
-       String tempo_str = StringConversion::int2hex_str( tempo_i, 4, '0' );
-       str += StringConversion::hex2bin_str( tempo_str );
+    String tempo_str = StringConversion::int2hex_str( tempo_i, 4, '0' );
+    str += StringConversion::hex2bin_str( tempo_str );
 
-       set( "MThd", str, "" );
+    set( "MThd", str, "" );
 }
 
 String
 Midi_item::int2varlength_str( int i )
 {
-       int buffer_i = i & 0x7f;
-       while ( (i >>= 7) > 0 ) {
-               buffer_i <<= 8;
-               buffer_i |= 0x80;
-               buffer_i += (i & 0x7f);
-       }
-
-       String str;
-       while ( 1 ) {
-               str += (char)buffer_i;
-               if ( buffer_i & 0x80 )
-                       buffer_i >>= 8;
-               else
-                       break;
-       }
-       return str;
+    int buffer_i = i & 0x7f;
+    while ( (i >>= 7) > 0 ) {
+       buffer_i <<= 8;
+       buffer_i |= 0x80;
+       buffer_i += (i & 0x7f);
+    }
+
+    String str;
+    while ( 1 ) {
+       str += (char)buffer_i;
+       if ( buffer_i & 0x80 )
+           buffer_i >>= 8;
+       else
+           break;
+    }
+    return str;
 }
 
 void 
 Midi_item::output_midi( Midi_stream& midi_stream_r )
 {
-       midi_stream_r << str();
+    midi_stream_r << str();
 }
 
 
 Midi_note::Midi_note( Melodic_req* melreq_l, int channel_i, bool on_bo  )
 {
-       pitch_i_ = melreq_l->pitch() + c0_pitch_i_c_;   
-       channel_i_ = channel_i;
-       on_bo_ = on_bo;
+
+    if (!melreq_l )
+       pitch_i_ = INT_MAX-1;   // any pitch. 
+    else
+        pitch_i_ = melreq_l->pitch() + c0_pitch_i_c_;
+    
+    channel_i_ = channel_i;
+
+    // poor man-s staff dynamics:
+    dynamic_byte_ =  (melreq_l)? 0x64 - 0x10 * channel_i_:0;
+    on_b_ = on_bo;
 }
 
 String
 Midi_note::str()
 {
-       if ( pitch_i_ != INT_MAX ) {
-               Byte status_by = ( on_bo_ ? 0x90 : 0x80 ) + channel_i_;
-               String str = String( (char)status_by );
-               str += (char)pitch_i_;
-               // poor man-s staff dynamics:
-               Byte dynamic_by = 0x64 - 0x10 * channel_i_;
-               str += (char)dynamic_by;
-               return str;
-       }
-       return String( "" );
+    if ( pitch_i_ != INT_MAX ) {
+       Byte status_byte = ( on_b_ ? 0x90 : 0x80 ) + channel_i_;
+       String str = String( (char)status_byte );
+       str += (char)pitch_i_;
+       // poor man-s staff dynamics:
+       str += (char)dynamic_byte_;
+       return str;
+    }
+    return String( "" );
 }
 
 Midi_track::Midi_track( int number_i )
@@ -139,40 +146,41 @@ Midi_track::Midi_track( int number_i )
 //         mi = 0:  major key
 //         mi = 1:  minor key
 
-       number_i_ = number_i;
+    number_i_ = number_i;
        
-       char const* data_ch_c_l = "00" "ff58" "0404" "0218" "08"
-                                 "00" "ff51" "0307" "a120"
+    char const* data_ch_c_l = "00" "ff58" "0404" "0218" "08"
+       "00" "ff51" "0307" "a120"
 // why a key at all, in midi?
 // key: C
-                                 "00" "ff59" "02" "00" "00"
+       "00" "ff59" "02" "00" "00"
 // key: F (scsii-menuetto)
 //                               "00" "ff59" "02" "ff" "00"
-                                 ;
+       ;
 
-       String data_str;
-       // only for format 0 (currently using format 1)?
-       data_str += StringConversion::hex2bin_str( data_ch_c_l );
+    String data_str;
+    // only for format 0 (currently using format 1)?
+    data_str += StringConversion::hex2bin_str( data_ch_c_l );
 
-       char const* footer_ch_c_l = "00" "ff2f" "00";
-       String footer_str = StringConversion::hex2bin_str( footer_ch_c_l );
+    char const* footer_ch_c_l = "00" "ff2f" "00";
+    String footer_str = StringConversion::hex2bin_str( footer_ch_c_l );
 
-       set( "MTrk", data_str, footer_str );
+    set( "MTrk", data_str, footer_str );
 }
 
 void 
 Midi_track::add( int delta_time_i, String event_str )
 {
-       Midi_chunk::add( int2varlength_str( delta_time_i ) + event_str );
+    assert(delta_time_i >= 0);
+    Midi_chunk::add( int2varlength_str( delta_time_i ) + event_str );
 }
 
 void 
 Midi_track::add( Moment delta_time_moment, Midi_item* mitem_l )
 {
-       // silly guess: 24 midi clocks per 4 note
-       // huh?
+    // silly guess: 24 midi clocks per 4 note
+    // huh?
 //     int delta_time_i = delta_time_moment / Moment( 1, 4 ) * Moment( 24 );
-       int delta_time_i = delta_time_moment / Moment( 1, 4 ) * Moment( 96 );
-       add( delta_time_i, mitem_l->str() );
+    int delta_time_i = delta_time_moment / Moment( 1, 4 ) * Moment( 96 );
+    add( delta_time_i, mitem_l->str() );
 }
 
diff --git a/src/midioutput.cc b/src/midioutput.cc
new file mode 100644 (file)
index 0000000..b17486e
--- /dev/null
@@ -0,0 +1,44 @@
+/*
+  midioutput.cc -- implement Midi_output
+
+  source file of the LilyPond music typesetter
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>, Jan Nieuwehuizen <jan@digicash.com> 
+*/
+#include "plist.hh"
+#include "debug.hh"
+#include "score.hh"
+#include "staff.hh"
+#include "midistream.hh"
+#include "mididef.hh"
+#include "midioutput.hh"
+#include "midiwalker.hh"
+#include "midiitem.hh"
+#include "stcol.hh"
+#include "musicalrequest.hh"
+
+
+Midi_output:: Midi_output(Score* score_l, Midi_def* midi_l )
+{
+    Midi_stream midi_stream(midi_l->outfile_str_,
+                           score_l->staffs_.size(),
+                           midi_l->get_tempo_i(Moment(1, 4)));
+
+    midi_stream_l_ = &midi_stream;
+    int track_i=0;
+
+    for (iter_top(score_l->staffs_,i); i.ok(); i++) {
+       do_staff(i, track_i++);
+    }
+
+}
+
+void
+Midi_output::do_staff(Staff*st_l,int track_i)
+{
+    Midi_track midi_track( track_i );
+    for (Midi_walker w (st_l, &midi_track); w.ok(); w++)
+       w.process_requests();
+
+    *midi_stream_l_  << midi_track;
+}  
index 5072fb6320caf681c8c619388f3fbe4c258e18a6..f1d74d87e47adee94e9d6484ceec854be3e82a6f 100644 (file)
@@ -6,38 +6,55 @@
   (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>, Jan Nieuwenhuizen <jan@digicash.com>
 */
 
-#include "misc.hh"
 #include "musicalrequest.hh"
-#include "voice.hh"
 #include "pscore.hh"
 #include "staff.hh"
-#include "midicolumn.hh"
-#include "midistaff.hh"
+#include "stcol.hh"
 #include "midiwalker.hh"
-#include "debug.hh"
 #include "midiitem.hh"
 #include "midistream.hh"
+#include "debug.hh"
 
-Midi_walker::Midi_walker( Midi_staff* mstaff_l )
-    : Staff_walker( mstaff_l, 0 )
-{
-}
-
-Midi_column*
-Midi_walker::mcol_l()
+Midi_walker::Midi_walker(Staff *st_l, Midi_track* track_l)
+    : PCursor<Staff_column*>(st_l->cols_)
 {
-       return (Midi_column*) *(*this);
+    track_l_ = track_l;
+    last_moment_= 0;
 }
 
-Midi_staff*
-Midi_walker::mstaff_l()
+void
+Midi_walker::do_stop_notes(Moment max_moment)
 {
-       return (Midi_staff*)staff_l_;
+    while (stop_notes.size() && stop_notes.front_idx() <= max_moment) {
+       Moment stop_moment = stop_notes.front_idx();
+       Melodic_req * req_l = stop_notes.get();
+       
+       Midi_note note(req_l, track_l_->number_i_, false);
+       
+       Moment delta_t = stop_moment-last_moment_ ;
+       last_moment_ += delta_t;
+       track_l_->add(delta_t, &note );
+    }
 }
 
 void
 Midi_walker::process_requests()
 {
-       allow_break();
+    do_stop_notes(ptr()->when());
+    for ( int i = 0; i < ptr()->musicalreq_l_arr_.size(); i++ )  {
+
+       Rhythmic_req *n = ptr()->musicalreq_l_arr_[i]->rhythmic();
+       if ( !n || !(n->note() || n->rest()) )
+           continue;
+       
+       Midi_note note(n->melodic(), track_l_->number_i_, true);
+       stop_notes.enter(n->melodic(), n->duration() + ptr()->when() );
+       Moment dt = 0;
+       track_l_->add(dt, &note);
+    }
 }
 
+Midi_walker::~Midi_walker()
+{
+    do_stop_notes( last_moment_ + Moment(10,1)); // ugh
+}