Duration dur = mom2standardised_dur( mom );
-// if ( dur.mom() == mom )
- if ( dur.length() == mom )
+// if ( !dur.mom() || ( dur.mom() == mom ) )
+ if ( !dur.length() || ( dur.length() == mom ) )
return dur;
assert( midi_as_plet_b_s );
for ( int i = 0; i < dur_array_s.size() - 1; i++ ) {
Moment lower_mom = dur2_mom( dur_array_s[ i ] );
if ( mom <= lower_mom ) {
- if ( i || ( mom / lower_mom > Moment( 3, 4 ) ) )
+ // all arbitrary, but 1/4 will get rid of the noise...
+// if ( i || ( mom / lower_mom > Moment( 3, 4 ) ) )
+//kinda ok if ( i || ( mom / lower_mom > Moment( 2, 4 ) ) )
+ if ( i || ( mom / lower_mom > Moment( 2, 6 ) ) )
return dur_array_s[ i ];
else
return Duration( 0 );
{
Moment mom( ticks_i, Duration::division_1_i_s );
Duration dur = mom2standardised_dur( mom );
-
-// if ( dur.mom() != mom )
- if ( dur.length() != mom )
- warning( String( "duration not exact: " ) + String( (Real)mom ) );
return dur;
}
MAJOR_VERSION = 0
MINOR_VERSION = 0
-PATCH_LEVEL = 62
+PATCH_LEVEL = 63
# use to send patches, always empty for released version:
# include separator: ".postfix", "-pl" makes rpm barf
*/
+/*
+ backup rules
+
+ after making a change to the lexer rules, run
+ flex -b <this lexer file>
+ and make sure that
+ lex.backup
+ contains no backup states, but only the reminder
+ Compressed tables always back up.
+ (don-t forget to rm lex.yy.cc :-)
+ */
+
+
#include <stdio.h>
#include "string.hh"
}
%[^{\n].*\n {
}
+ %[^{\n] { // backup rule
+ }
%\n {
}
+ %[^{\n].* {
+ }
{WHITE}+ {
}
new_input(s,source_l_g);
yy_pop_state();
}
+<incl>\"[^"]* { // backup rule
+ cerr << "missing end quote" << endl;
+ exit( 1 );
+}
<notes>{RESTNAME} {
const char *s = YYText();
yylval.string = new String (s);
s=s.left_str(s.length_i() - 1);
return scan_bare_word(s);
}
+<INITIAL,lyrics,notes>\\\${BLACK}* { // backup rule
+ cerr << "white expected" << endl;
+ exit( 1 );
+}
+<INITIAL,lyrics,notes>\${BLACK}* { // backup rule
+ cerr << "white expected" << endl;
+ exit( 1 );
+}
<notes>{
{ALPHAWORD}/\' {
post_quotes_b_ = true;
return REAL;
}
+{INT}\. { // backup rule
+ cerr << "int. encountered" << endl;
+ exit( 1 );
+}
+
[{}] {
mtor << "parens\n";
$(outdir)/%.cc: %.l
$(FLEX) -Cfe -p -p -t $< > $@
+# could be faster:
+# $(FLEX) -8 -Cf -t $< > $@
$(outdir)/%.text: $(outdir)/%.1
groff -man -Tascii $< > $@
MAJOR_VERSION = 0
MINOR_VERSION = 0
-PATCH_LEVEL = 15
+PATCH_LEVEL = 16
# use to send patches, always empty for released version:
MY_PATCH_LEVEL =
#
#undef mtor
#endif
+#define MVOICE_LIST
+
#include "string.hh"
#include "string-convert.hh"
int number_i_;
private:
- void add_begin_at( Pointer_list<Midi_voice*>& open_voices_r, Moment mom );
+#ifdef MVOICE_LIST
+ void add_begin_at( Link_list<Midi_voice*>& open_voices_r, Moment mom );
+#else
+ void add_begin_at( Array<Midi_voice*>& open_voices_r, Moment mom );
+#endif
int check_begin_bar_i( Moment now_mom, int open_bar_i );
int check_end_bar_i( Moment now_mom, int open_bar_i );
Midi_voice* get_free_midi_voice_l( Moment mom );
- void remove_end_at( Pointer_list<Midi_voice*>& open_voices_r, Moment mom );
+#ifdef MVOICE_LIST
+ void remove_end_at( Link_list<Midi_voice*>& open_voices_r, Moment mom );
+#else
+ void remove_end_at( Array<Midi_voice*>& open_voices_r, Moment mom );
+#endif
void output_mudela_begin_bar( Lily_stream& lily_stream_r, Moment now_mom, int bar_i );
void output_mudela_rest( Lily_stream& lily_stream_r, Moment begin_mom, Moment end_mom );
void output_mudela_rest_remain( Lily_stream& lily_stream_r, Moment mom );
- IPointer_list<Track_column*> tcol_p_list_;
- IPointer_list<Midi_voice*> midi_voice_p_list_;
+#ifdef TCOL_LIST
+#warning using track_column list
+ Pointer_list<Track_column*> tcol_p_list_;
+#else
+ Array<Track_column*> tcol_p_array_;
+#endif
+#ifdef MVOICE_LIST
+#warning using midi_voice list
+ Pointer_list<Midi_voice*> midi_voice_p_list_;
+#else
+ Array<Midi_voice*> midi_voice_p_array_;
+#endif
};
#endif // MIDI_TRACK_HH
Moment begin_mom();
Moment end_mom();
- String mudela_str( Moment to_mom, Moment to_mom, bool multiple_bo );
- // ARE you sure? ^^ ^^
+ String mudela_str( Moment from_mom, Moment to_mom, bool multiple_bo );
private:
- int events_i_;
- Moment end_mom_;
- Moment begin_mom_;
- IPointer_list<Midi_event*> midi_event_p_list_;
+ int events_i_;
+ Moment end_mom_;
+ Moment begin_mom_;
+#ifdef MEVENT_LIST
+#error using list
+ Pointer_list<Midi_event*> midi_event_p_list_;
+#else
+ Array<Midi_event*> midi_event_p_array_;
+#endif
};
#endif // MIDI_VOICE_HH
Moment mom();
//private:
- IPointer_list<Midi_event*> midi_event_p_list_;
+#ifdef MEVENT_LIST
+#error using list
+ Pointer_list<Midi_event*> midi_event_p_list_;
+#else
+ Array<Midi_event*> midi_event_p_array_;
+#endif
Moment mom_;
};
0,0,0
};
Getopt_long getopt_long( argc_i, argv_sz_a, long_option_init_a );
- identify();
String output_str;
while ( Long_option_init* long_option_init_p = getopt_long() )
level_ver = DEBUG_ver;
break;
case 'h':
+ identify();
usage();
exit( 0 );
break;
case 's': {
int i = String_convert::dec2_i( getopt_long.optarg );
if ( !i ) {
+ identify();
usage();
exit( 2 ); //usage
}
level_ver = VERBOSE_ver;
break;
case 'w':
+ identify();
notice();
exit( 0 );
break;
break;
}
+ // flag -q must be checked first
+ identify();
+
char* arg_sz = 0;
while ( ( arg_sz = getopt_long.get_next_arg() ) ) {
My_midi_parser midi_parser( arg_sz, & source );
%{//-*-Fundamental-*-
// midi-lexer.l
+/*
+ backup rules
+
+ after making a change to the lexer rules, run
+ flex -b <this lexer file>
+ and make sure that
+ lex.backup
+ contains no backup states, but only the reminder
+ Compressed tables always back up.
+ (don-t forget to rm lex.yy.cc :-)
+ */
#include "mi2mu.hh"
#include "midi-parser.hh"
U8 [\x00-\xff]
I8 {U8}
INT16 {U8}{U8}
+BACKUP_INT16_0 {U8}
INT32 {INT16}{INT16}
+BACKUP_INT32_0 {U8}
+BACKUP_INT32_1 {U8}{U8}
+BACKUP_INT32_2 {INT16}{U8}
INT7_8UNSET [\x00-\x7f]
INT7_8SET [\x80-\xff]
VARINT {INT7_8SET}{0,3}{INT7_8UNSET}
+BACKUP_VARINT_0 {INT7_8SET}
+BACKUP_VARINT_1 {INT7_8SET}{INT7_8SET}
+BACKUP_VARINT_2 {INT7_8SET}{INT7_8SET}{INT7_8SET}
HEADER MThd
TRACK MTrk
+BACKUP_TOP_0 MT
+BACKUP_TOP_1 MTh
+BACKUP_TOP_2 MTr
XRUNNING_STATUS [\x30-\x4f]
RUNNING_STATUS [\x00-\x5f]
%%
-{HEADER}/{INT32} { // using /{INT32}; longer match than {INT32}
+{HEADER} { // huh? using {HEADER}/{INT32}; longer match than {INT32}
tor( DEBUG_ver ) << "lex: header" << endl;
yy_push_state( int16 );
yy_push_state( int16 );
return HEADER;
}
-{TRACK}/{INT32} { // using /{INT32}; longer match than {INT32}
+{TRACK} { // huh? using {TRACK}/{INT32}; longer match than {INT32}
tor( DEBUG_ver ) << "lex: track" << endl;
yy_push_state( track );
yy_push_state( int32 );
return TRACK;
}
{U8} {
- error( String( "top level: illegal byte: " )
+ error( String( "top level: header expected: " )
+ String_convert::bin2hex_str( String( *YYText() ) ) );
exit( 1 );
}
+{BACKUP_TOP_0} {
+ error( String( "top level: header expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+{BACKUP_TOP_1} {
+ error( String( "top level: header expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+{BACKUP_TOP_2} {
+ error( String( "top level: header expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
<int32>{INT32} { // really signed?
tor( DEBUG_ver ) << "lex: int32" << endl;
assert( YYLeng() == 4 );
yy_pop_state();
return INT32;
}
+<int32>{BACKUP_INT32_0} {
+ error( String( "int32: int32 expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<int32>{BACKUP_INT32_1} {
+ error( String( "int32: int32 expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<int32>{BACKUP_INT32_2} {
+ error( String( "int32: int32 expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
<int16>{INT16} { // really signed?
tor( DEBUG_ver ) << "lex: int16" << endl;
assert( YYLeng() == 2 );
String str( (Byte const*)YYText(), YYLeng() );
- yylval.i = String_convert::bin2_i( str );
+ yylval.i = (short)String_convert::bin2_i( str );
yy_pop_state();
return INT16;
}
+<int16>{BACKUP_INT16_0} {
+ error( String( "int16: int16 expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
<i8>{I8} {
tor( DEBUG_ver ) << "lex: i8" << endl;
assert( YYLeng() == 1 );
+ String_convert::bin2hex_str( String( *YYText() ) ) );
exit( 1 );
}
+<track>{BACKUP_VARINT_0}{U8} {
+ error( String( "track: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<track>{BACKUP_VARINT_1}{U8} {
+ error( String( "track: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<track>{BACKUP_VARINT_2}{U8} {
+ error( String( "track: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
<event>{RUNNING_STATUS} {
// yylval.byte = *(Byte*)YYText();
yylval.i = *(Byte*)YYText();
+ String_convert::bin2hex_str( String( *YYText() ) ) );
exit( 1 );
}
+<data>{BACKUP_VARINT_0}{U8} {
+ error( String( "data: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<data>{BACKUP_VARINT_1}{U8} {
+ error( String( "data: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
+<data>{BACKUP_VARINT_2}{U8} {
+ error( String( "data: varint expected: " )
+ + String_convert::bin2hex_str( String( *( YYText() ) ) ) );
+ exit( 1 );
+}
<<EOF>> {
// tor( NORMAL_ver ) << "<<EOF>>";
name_str_ = track_name_str;
midi_time_p_ = new Midi_time( 4, 2, 24, 8 );
midi_tempo_p_ = new Midi_tempo( 1000000 );
+#ifdef TCOL_LIST
+#error doing list!
tcol_p_list_.bottom().add( new Track_column( Moment( 0 ) ) );
+#else
+ tcol_p_array_.push( new Track_column( Moment( 0 ) ) );
+#endif
}
Midi_track::~Midi_track()
delete midi_tempo_p_;
}
+#ifdef MVOICE_LIST
void
-Midi_track::add_begin_at( Pointer_list<Midi_voice*>& open_voices_r, Moment mom )
+Midi_track::add_begin_at( Link_list<Midi_voice*>& open_voices_r, Moment mom )
{
for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
if ( i->begin_mom() == mom ) {
open_voices_r.bottom().add( *i );
}
}
+#else
+void
+Midi_track::add_begin_at( Array<Midi_voice*>& open_voices_r, Moment mom )
+{
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ )
+ if ( midi_voice_p_array_[ i ]->begin_mom() == mom ) {
+ tor( DEBUG_ver ) << "open_voices (" << open_voices_r.size() << "): +1\n";
+ open_voices_r.push( midi_voice_p_array_[ i ] );
+ }
+}
+#endif
void
Midi_track::add_event( Moment mom, Midi_event* midi_event_p )
{
// heu..
Moment mom = 0.0;
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
mom = i->end_mom() >? mom;
+#else
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ )
+ mom = midi_voice_p_array_[ i ]->end_mom() >? mom;
+#endif
return mom;
}
Midi_voice*
Midi_track::get_free_midi_voice_l( Moment mom )
{
- for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
+#ifdef MVOICE_LIST
+ Real f = mom;
+ for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ ) {
+ Real e = i->end_mom();
if ( i->end_mom() == mom )
return *i;
+ }
Midi_voice* midi_voice_p = new Midi_voice( mom );
Midi_voice* midi_voice_l = midi_voice_p;
midi_voice_p_list_.bottom().add( midi_voice_p );
return midi_voice_l;
+#else
+ Real f = mom;
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ ) {
+ Real e = i->end_mom();
+ if ( midi_voice_p_array_[ i ]->end_mom() == mom )
+ return midi_voice_p_array_[ i ];
+ }
+
+ Midi_voice* midi_voice_p = new Midi_voice( mom );
+ Midi_voice* midi_voice_l = midi_voice_p;
+ midi_voice_p_array_.push( midi_voice_p );
+ return midi_voice_l;
+#endif
}
String
{
// Moment begin_mom = Midi_track::end_mom() + 1;
Moment begin_mom = Midi_track::end_mom();
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
-// if ( i->begin_mom() >= now_mom )
+// if ( i->begin_mom() >= now_mom )// well, which one ?
if ( i->begin_mom() > now_mom )
begin_mom = begin_mom <? i->begin_mom();
+#else
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ )
+ if ( midi_voice_p_array_[ i ]->begin_mom() >= now_mom ) // well, which one ?
+ if ( midi_voice_p_array_[ i ]->begin_mom() > now_mom )
+// begin_mom = begin_mom <? midi_voice_p_array_[ i ]->begin_mom();
+#endif
return begin_mom;
}
Midi_track::next_end_mom( Moment now_mom )
{
Moment end_mom = Midi_track::end_mom();
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
if ( i->end_mom() > now_mom )
end_mom = end_mom <? i->end_mom();
+#else
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ )
+// if ( midi_voice_p_array_[ i ]->end_mom() >= now_mom )
+ if ( midi_voice_p_array_[ i ]->end_mom() > now_mom )
+ end_mom = end_mom <? midi_voice_p_array_[ i ]->end_mom();
+#endif
return end_mom;
}
/*
columns to voices
*/
- int bar_i = 1;
+// int bar_i = 1;
+ int bar_i = 0;
+#ifdef TCOL_LIST
for ( PCursor<Track_column*> i( tcol_p_list_.top() ); i.ok(); i++ ) {
int begin_bar_i = check_begin_bar_i( i->mom(), bar_i );
if ( begin_bar_i )
get_free_midi_voice_l( i->mom() )->add_event( i->midi_event_p_list_.top().remove_p() );
bar_i = check_end_bar_i( i->mom(), bar_i );
}
+#else
+ for ( int i = 0; i < tcol_p_array_.size(); i++ ) {
+ Track_column* tcol_l = tcol_p_array_[ i ];
+ int begin_bar_i = check_begin_bar_i( tcol_l->mom(), bar_i );
+ if ( begin_bar_i )
+ tor( NORMAL_ver ) << begin_bar_i << flush;
+#ifdef MEVENT_LIST
+ while ( tcol_l->midi_event_p_list_.size() )
+ get_free_midi_voice_l( tcol_l->mom() )->add_event( tcol_l->midi_event_p_list_.top().remove_p() );
+#else
+ // what's efficient here?
+#if 0 // heu, what's different here?
+ while ( tcol_l->midi_event_p_array_.size() ) {
+ get_free_midi_voice_l( tcol_l->mom() )->add_event( tcol_l->midi_event_p_array_[ 0 ] );
+ tcol_l->midi_event_p_array_.del( 0 );
+ }
+#else
+ for ( int i = 0; i < tcol_l->midi_event_p_array_.size(); i++ ) {
+ get_free_midi_voice_l( tcol_l->mom() )->add_event( tcol_l->midi_event_p_array_[ i ] );
+ tcol_l->midi_event_p_array_[ i ] = 0;
+ }
+ tcol_l->midi_event_p_array_.clear();
+#endif
+#endif
+ bar_i = check_end_bar_i( tcol_l->mom(), bar_i );
+ }
+#endif
tor( DEBUG_ver ) << "ends: " << endl;
int n = 0;
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( midi_voice_p_list_.top() ); i.ok(); i++ )
tor( VERBOSE_ver ) << "voice " << n++ << ": " << i->end_mom() << endl;
+#else
+ for ( int i = 0; i < midi_voice_p_array_.size(); i++ )
+ tor( VERBOSE_ver ) << "voice " << n++ << ": " << midi_voice_p_array_[ i ]->end_mom() << endl;
+#endif
tor( DEBUG_ver ) << ":sdne" << endl;
}
lily_stream_r << "% instrument:" << instrument_str_;
lily_stream_r.newline();
+// int bar_i = 1;
int bar_i = 0;
- Pointer_list<Midi_voice*> open_voices;
+#ifdef MVOICE_LIST
+ Link_list<Midi_voice*> open_voices;
+#else
+ Array<Midi_voice*> open_voices;
+#endif
Moment now_mom = 0.0;
Real now_f = now_mom;
Real begin_f = 0;
if ( start_of_track_bo ) {
start_of_track_bo = false;
String str;
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( open_voices.top() ); i.ok(); i++ )
lily_stream_r << i->mudela_str( now_mom, then_mom, open_voices.size() - 1 );
+#else
+ for ( int i = 0; i < open_voices.size(); i++ )
+ lily_stream_r << open_voices[ i ]->mudela_str( now_mom, then_mom, open_voices.size() - 1 );
+#endif
if ( str.length_i() )
lily_stream_r << str;
else
output_mudela_rest( lily_stream_r, now_mom, then_mom );
}
else {
+#ifdef MVOICE_LIST
for ( PCursor<Midi_voice*> i( open_voices.top() ); i.ok(); i++ )
lily_stream_r << i->mudela_str( now_mom, then_mom, open_voices.size() - 1 );
+#else
+ for ( int i = 0; i < open_voices.size(); i++ )
+ lily_stream_r << open_voices[ i ]->mudela_str( now_mom, then_mom, open_voices.size() - 1 );
+#endif
if ( !open_voices.size() )
output_mudela_rest( lily_stream_r, now_mom, then_mom );
}
now_mom = then_mom;
}
- bar_i++;
- tor( NORMAL_ver ) << '[' << bar_i << ']' << flush;
+// bar_i++;
+// tor( NORMAL_ver ) << '[' << bar_i << ']' << flush;
lily_stream_r.tnedni();
lily_stream_r << "} % " << name_str();
output_mudela_begin_bar( lily_stream_r, now_mom, begin_bar_i );
lily_stream_r << "r1 ";
// *lily_stream_r.os_p_ << flush;
- tor( NORMAL_ver ) << begin_bar_i << flush;
+ if ( begin_bar_i )
+ tor( NORMAL_ver ) << begin_bar_i << flush;
bar_i = check_end_bar_i( now_mom, bar_i );
now_mom += bar_mom;
}
lily_stream_r << "r" << dur.str() << " ";
}
+
+#ifdef MVOICE_LIST
void
-Midi_track::remove_end_at( Pointer_list<Midi_voice*>& open_voices_r, Moment mom )
+Midi_track::remove_end_at( Link_list<Midi_voice*>& open_voices_r, Moment mom )
{
for ( PCursor<Midi_voice*> i( open_voices_r.top() ); i.ok(); i++ )
// if ( i->end_mom() == mom ) { }
break;
}
}
+#else
+void
+Midi_track::remove_end_at( Array<Midi_voice*>& open_voices_r, Moment mom )
+{
+ for ( int i = 0; i < open_voices_r.size(); i++ )
+ if ( midi_voice_p_array_[ i ]->end_mom() <= mom ) {
+ tor( DEBUG_ver ) << "open_voices (" << open_voices_r.size() << "): -1\n";
+ open_voices_r[ i ] = 0;
+// open_voices_r.del( i-- );
+ open_voices_r.del( i );
+ }
+}
+#endif
void
Midi_track::set_tempo( int useconds_per_4_i )
Track_column*
Midi_track::tcol_l( Moment mom )
{
+#ifdef TCOL_LIST
for ( PCursor<Track_column*> i( tcol_p_list_.top() ); i.ok(); i++ ) {
- if ( i->mom() == mom )
- return *i;
- if ( i->mom() > mom ) {
+ if ( i->mom() > mom ) { //not used, let's use array!
+ assert( 0 );
Track_column* tcol_p = new Track_column( mom );
i.insert( tcol_p );
return tcol_p;
}
+ if ( i->mom() == mom )
+ return *i;
}
Track_column* tcol_p = new Track_column( mom );
tcol_p_list_.bottom().add( tcol_p );
return tcol_p;
+#elif 0
+ for ( int i = 0; i < tcol_p_array_.size(); i++ )
+ if ( tcol_p_array_[ i ]->mom() == mom )
+ return tcol_p_array_[ i ];
+
+ Track_column* tcol_p = new Track_column( mom );
+ tcol_p_array_.push( tcol_p );
+ return tcol_p;
+#else
+ /*
+ as "insert" is never called, the right column will
+ always be found, unless mom > tcol_p_array[ i ]->mom().
+ */
+ int upper_i = max( 0, tcol_p_array_.size() - 1 );
+ int lower_i = 0;
+ int i = upper_i;
+ while ( 1 ) {
+ Moment i_mom = tcol_p_array_[ i ]->mom();
+ if ( i_mom == mom )
+ return tcol_p_array_[ i ];
+ if ( mom < i_mom )
+ upper_i = i;
+ else
+ lower_i = i;
+ if ( ( upper_i == lower_i ) || ( i == tcol_p_array_.size() - 1 ) ) {
+// huh? assert ( upper_i == tcol_p_array_.size() );
+ Track_column* tcol_p = new Track_column( mom );
+ tcol_p_array_.push( tcol_p );
+ return tcol_p;
+ }
+ i = ( upper_i + lower_i + 1 ) / 2;
+ }
+ assert( 0 );
+ return 0;
+#endif
}
void
Midi_voice::add_event( Midi_event* midi_event_p )
{
+#ifdef MEVENT_LIST
midi_event_p_list_.bottom().add( midi_event_p );
+#else
+ midi_event_p_array_.push( midi_event_p );
+#endif
}
Moment
Moment
Midi_voice::end_mom()
{
+#ifdef MEVENT_LIST
// if ( events_i_ == midi_event_p_list_.length_i() )
if ( events_i_ == midi_event_p_list_.size() )
return end_mom_;
// events_i_ = midi_event_p_list_.length_i();
events_i_ = midi_event_p_list_.size();
return end_mom_;
+#else
+ if ( events_i_ == midi_event_p_array_.size() )
+ return end_mom_;
+ Moment now_mom = begin_mom_;
+ tor( DEBUG_ver ) << now_mom << ", ";
+ for ( int i = 0; i < midi_event_p_array_.size(); i++ ) {
+ tor( DEBUG_ver ) << now_mom << ", ";
+ now_mom += midi_event_p_array_[ i ]->mom();
+ }
+ tor( DEBUG_ver ) << endl;
+ end_mom_ = now_mom;
+ events_i_ = midi_event_p_array_.size();
+ return end_mom_;
+#endif
}
String
{
String str;
- if ( begin_mom() >= to_mom )
+// if ( begin_mom() >= to_mom )
+ if ( begin_mom() > to_mom )
return "";
- if ( end_mom() <= from_mom )
+// if ( end_mom() <= from_mom )
+ if ( end_mom() < from_mom )
return "";
Moment now_mom = begin_mom();
+#ifdef MEVENT_LIST
PCursor<Midi_event*> i( midi_event_p_list_.top() );
for ( ; i.ok() && now_mom < from_mom ; i++ )
now_mom += i->mom();
now_mom += i->mom();
str += i->mudela_str( false ) + " ";
}
+#else
+ int i = 0;
+ for ( ; i < midi_event_p_array_.size() && now_mom < from_mom ; i++ )
+ now_mom += midi_event_p_array_[ i ]->mom();
+
+ for ( ; i < midi_event_p_array_.size() && now_mom < to_mom ; i++ ) {
+ now_mom += midi_event_p_array_[ i ]->mom();
+ str += midi_event_p_array_[ i ]->mudela_str( false ) + " ";
+ }
+#endif
if ( str.length_i() && multiple_bo )
str = "{ " + str + "} ";
void
My_midi_parser::forward( int i )
{
- now_i64_ += i;
+ if ( Duration_convert::no_quantify_b_s ) {
+ now_i64_ += i;
+ return;
+ }
+ while ( i > Duration::division_1_i_s ) {
+ now_i64_ += Duration::division_1_i_s;
+ i -= Duration::division_1_i_s;
+ }
+ Duration dur = Duration_convert::ticks2standardised_dur( i );
+ now_i64_ += Duration_convert::dur2ticks_i( dur );
}
Moment
Duration dur( 0 );
if ( Duration_convert::no_quantify_b_s )
dur = Duration_convert::ticks2_dur( (I64)now_i64_ - start_i64 );
- else
+ else {
dur = Duration_convert::ticks2standardised_dur( (I64)now_i64_ - start_i64 );
+ // checking myself iso using tor saves some time
+ if ( level_ver >= VERBOSE_ver ) {
+ Moment mom( (I64)now_i64_ - start_i64, Duration::division_1_i_s );
+ if ( dur.length() != mom )
+ warning( String( "duration not exact: " ) + String( (Real)mom ) );
+ }
+ }
return new Midi_note( midi_key_p_->notename_str( pitch_i ), dur );
}
#include "plist.hh"
#include "plist.tcc"
-IPL_instantiate(Midi_event);
+//IPL_instantiate(Midi_event);
IPL_instantiate(Midi_track);
-PL_instantiate(Midi_voice);
-IPL_instantiate(Midi_voice);
-IPL_instantiate(Track_column);
+// PL_instantiate(Midi_voice);
+// IPL_instantiate(Midi_voice);
+//IPL_instantiate(Track_column);
void
Track_column::add_event( Midi_event* midi_event_p )
{
+#ifdef MEVENT_LIST
midi_event_p_list_.bottom().add( midi_event_p );
+#else
+ midi_event_p_array_.push( midi_event_p );
+#endif
}
Moment
projects / lilypond.git / commitdiff