00324     : 
00325     input_stream( input_stream_ ),
00326     event_handler( event_handler_ )
00327   {
00328     no_merge=0;
00329     cur_time=0;
00330     skip_init=1;
00331     to_be_read=0;
00332     msg_index=0;
00333     cur_track=0;
00334     abort_parse=0;
00335     max_msg_len=max_msg_len_;
00336     the_msg = new unsigned char[max_msg_len];
00337   }

00340   {
00341     delete [] the_msg;
00342   }

00691   {
00692     mf_error( "Unexpected Byte" );
00693     abort_parse=true;
00694   }

00661   {
00662     int c;
00663     
00664     c = input_stream->ReadChar();
00665     
00666     
00667     if( c<0 )
00668     {
00669       mf_error( "Unexpected Stream Error" );
00670       abort_parse=true;
00671       return -1;
00672     }
00673     
00674     --to_be_read;
00675     
00676     return (int)c;
00677   }

00697   {
00698     MIDITimedMessage m;
00699     
00700     m.SetStatus( st );
00701     m.SetByte1( b1 );
00702     m.SetByte2( b2 );
00703     m.SetTime( cur_time );
00704     
00705     if( st>=0x80 && st<0xf0 )
00706     {
00707       event_handler->ChanMessage(m);
00708     }
00709     
00710   }

00174 { return header_division; }

00172 { return header_format;   }

00173 { return header_ntrks;    }

00345   {
00346     event_handler->mf_error(e);
00347     abort_parse=true;   
00348   }

00680   {
00681     if( msg_index<max_msg_len )
00682       the_msg[ msg_index++ ] = (unsigned char)a;
00683   }

00686   {
00687     msg_index=0;
00688   }

00351   {
00352     int n;
00353     
00354     n = ReadHeader();
00355     if( n <=0 )
00356     {
00357       mf_error( "No Tracks" );
00358       return false;
00359     }
00360     for( cur_track=0; cur_track<n; cur_track++ )
00361     {
00362       ReadTrack();
00363       if( abort_parse )
00364       {
00365         return false;
00366       }
00367     }
00368     return true;
00369   }

00651   {
00652     int c1, c2;
00653     
00654     c1=EGetC();
00655     c2=EGetC();
00656     
00657     return To16Bit( (unsigned char)c1, (unsigned char)c2 );
00658   }

00639   {
00640     int c1, c2, c3, c4;
00641     
00642     c1=EGetC();
00643     c2=EGetC();
00644     c3=EGetC();
00645     c4=EGetC();
00646     
00647     return To32Bit( (unsigned char)c1, (unsigned char)c2, (unsigned char)c3, (unsigned char)c4 );
00648   }

00404   {
00405     int   the_format;
00406     int  ntrks;
00407     int   division;
00408     
00409     if( ReadMT( _MThd, skip_init )==0xffff )
00410       return 0;
00411     
00412     if( abort_parse )
00413       return 0;
00414     
00415     to_be_read = Read32Bit();
00416     the_format=Read16Bit();
00417     ntrks=Read16Bit();
00418     division=Read16Bit();
00419     
00420     if( abort_parse )
00421       return 0;
00422     
00423     
00424     header_format=the_format;
00425     header_ntrks=ntrks;
00426     header_division=division;
00427     
00428     event_handler->mf_header( the_format, ntrks, division );
00429     
00430     
00431     // printf( "\nto be read = %d\n", to_be_read );
00432     
00433     while( to_be_read > 0 )
00434       EGetC();
00435     
00436     return ntrks;
00437   }

00372   {
00373     unsigned long read=0;
00374     int c;       
00375     
00376     read=OSTYPE( EGetC(), EGetC(), EGetC(), EGetC() );
00377     if( type!=read )
00378     {
00379       if( skip )
00380       {
00381         do
00382         {
00383           read<<=8;
00384           c=EGetC();
00385           read|=c;
00386           if( read==type )
00387             return true;
00388           if( abort_parse )
00389             return false;
00390           
00391         } while( c!=-1 );
00392       }
00393       mf_error( "Error looking for chunk type" );
00394       return false;
00395     }
00396     else
00397     {
00398       return true;
00399     }
00400     
00401   }

00444   {
00445     //
00446     // This array is indexed by the high half of a status byte.  Its
00447     // value is either the number of bytes needed (1 or 2) for a channel
00448     // message, or 0 (meaning it's not  a channel message).
00449     //
00450     
00451     static char chantype[] = 
00452       {
00453         0, 0, 0, 0, 0, 0, 0, 0,         // 0x00 through 0x70
00454         2, 2, 2, 2, 1, 1, 2, 0          // 0x80 through 0xf0
00455       };
00456     
00457     unsigned long lookfor, lng;
00458     int c, c1, type;
00459     int sysexcontinue=0; // 1 if last message was unfinished sysex
00460     int running=0;       // 1 when running status used
00461     int status=0;                // (possible running) status byte
00462     int needed;
00463     
00464     
00465     if( ReadMT( _MTrk, 0) == 0xffff )
00466       return;
00467     
00468     to_be_read=Read32Bit();
00469     cur_time=0;
00470     
00471     event_handler->mf_starttrack( cur_track );
00472     
00473     while( to_be_read > 0 && !abort_parse )
00474     {
00475       unsigned long deltat=ReadVariableNum();
00476       
00477       event_handler->UpdateTime( deltat );
00478       
00479       cur_time += deltat;
00480       
00481       c=EGetC();
00482       
00483       if( c==-1 )
00484         break;
00485       
00486       if( sysexcontinue && c!=0xf7 )
00487         mf_error( "Error after expected continuation of SysEx" );
00488       
00489       if( (c&0x80)==0 )
00490       {
00491         if( status==0 )
00492           mf_error( "Unexpected Running Status" );
00493         running=1;
00494         needed = chantype[ (status>>4) & 0xf ];
00495       }
00496       else
00497       {
00498         // TO DO: is running status to be cleared or not when meta event happens?
00499         
00500 #if MIDIFRD_ALLOW_STATUS_ACROSS_META_EVENT
00501         if(  c!=0xff )
00502         {
00503           status=c;
00504           running=0;
00505           needed=0;
00506         }
00507         
00508 #else
00509         status=c;
00510         running=0;
00511         needed = chantype[ (status>>4) & 0xf ]; 
00512 #endif
00513         
00514       }
00515       
00516       
00517       
00518       if( needed )            // ie. is it a channel message?
00519       {
00520         if( running )
00521           c1=c;
00522         else
00523           c1=EGetC();
00524         FormChanMessage( (unsigned char)status, (unsigned char)c1, (unsigned char)((needed>1) ? EGetC() : 0 ));
00525         continue;
00526       }
00527       
00528       
00529       switch( c )
00530       {
00531       case 0xff:              // meta-event
00532         type=EGetC();
00533         lng = ReadVariableNum();
00534         
00535         lookfor = to_be_read - lng;
00536         
00537         MsgInit();
00538         while( to_be_read > lookfor)
00539         {
00540           MsgAdd( EGetC() );
00541         }
00542         
00543         event_handler->MetaEvent( cur_time, type, msg_index, the_msg );
00544         break;
00545         
00546       case 0xf0:              // start of sys-ex
00547         lng = ReadVariableNum();
00548         lookfor = to_be_read - lng;
00549         
00550         MsgInit();
00551         MsgAdd(0xf0);
00552         
00553         while( to_be_read>lookfor )
00554           MsgAdd( c=EGetC() );
00555         
00556         if( c==0xf7 || no_merge==0 )
00557         {
00558           // make a sysex object out of the raw sysex data
00559           // the buffer is not to be deleted upon destruction of ex
00560           
00561           MIDISystemExclusive ex(
00562             the_msg,
00563             msg_index,
00564             msg_index,
00565             false
00566             );
00567           
00568           // give the sysex object to our event handler
00569           
00570           event_handler->mf_sysex( cur_time, ex );
00571         }
00572         else
00573           sysexcontinue=1; // merge into next msg
00574         break;
00575       case 0xf7:              // sysex continuation or 
00576         // arbitary stuff
00577         lng=ReadVariableNum();
00578         lookfor = to_be_read - lng;
00579         
00580         if( ! sysexcontinue )
00581           MsgInit();
00582         
00583         while( to_be_read > lookfor )
00584           MsgAdd(c=EGetC());
00585         
00586         if( !sysexcontinue )
00587         {
00588           event_handler->mf_arbitrary( cur_time, msg_index, the_msg );
00589         }
00590         else if( c== 0xf7 )
00591         {
00592           // make a sysex object out of the raw sysex data
00593           // the buffer is not to be deleted upon destruction of ex
00594           
00595           MIDISystemExclusive ex(
00596             the_msg,
00597             msg_index,
00598             msg_index,
00599             false
00600             );
00601           event_handler->mf_sysex( cur_time, ex );
00602           sysexcontinue=0;
00603         }
00604         break;
00605       default:
00606         BadByte(c);
00607         break;
00608       }
00609     }
00610     event_handler->mf_endtrack( cur_track );
00611     return;
00612   }

00615   {
00616     unsigned long value;
00617     int c;
00618     
00619     c=EGetC();
00620     if( c==-1 )
00621     {
00622       return 0;
00623     }
00624     value = c;
00625     
00626     if( c & 0x80 )
00627     {
00628       value &= 0x7f;
00629       do
00630       {
00631         c=EGetC();
00632         value =  (value<<7) + (c&0x7f);
00633       } while( c&0x80 );
00634     }
00635     return value;
00636   }


Public Member Functions
	MIDIFileRead (MIDIFileReadStream input_stream_, MIDIFileEvents event_handler_, unsigned long max_msg_len=8192)
virtual	~MIDIFileRead ()
virtual bool	Parse ()
int	GetFormat ()
int	GetNumberTracks ()
int	GetDivision ()
Protected Member Functions
virtual int	ReadHeader ()
virtual void	mf_error (char *)
Protected Attributes
int	no_merge
MIDIClockTime	cur_time
int	skip_init
unsigned long	to_be_read
int	cur_track
int	abort_parse
unsigned char *	the_msg
int	max_msg_len
int	msg_index
Private Member Functions
unsigned long	ReadVariableNum ()
unsigned long	Read32Bit ()
int	Read16Bit ()
void	ReadTrack ()
void	MsgAdd (int)
void	MsgInit ()
int	EGetC ()
int	ReadMT (unsigned long, int)
void	BadByte (int)
void	FormChanMessage (unsigned char st, unsigned char b1, unsigned char b2)
Private Attributes
int	header_format
int	header_ntrks
int	header_division
MIDIFileReadStream *	input_stream
MIDIFileEvents *	event_handler

jdkmidi::MIDIFileRead Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation