00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "Track.h"
00024
00025 #include "ChannelControllerEvent.h"
00026 #include "MetaGenericEvent.h"
00027 #include "MetaTextEvent.h"
00028 #include "MetaNumberEvent.h"
00029 #include "Defines.h"
00030
00031 #include <iostream>
00032 #include <iomanip>
00033 using namespace std;
00034
00035 namespace MIDI
00036 {
00037 Track::Track()
00038 { }
00039
00040 Track::Track(byte* data,dword size)
00041 : _data(data),_size(size),_pos(0)
00042 {
00043 byte lastMIDICommand;
00044 int lastChannel;
00045
00046 while(_pos<_size)
00047 {
00048 dword deltaTime=readNextVariableLength();
00049 byte eventType=readNextByte();
00050
00051 switch(eventType)
00052 {
00053 case 0xFF:
00054 {
00055 byte type=readNextByte();
00056 dword length=readNextVariableLength();
00057 byte metaData[length];
00058 for(int i=0;i<length;i++)
00059 {
00060 metaData[i]=readNextByte();
00061 }
00062
00063 MetaEvent *event;
00064 switch(type)
00065 {
00066 case MIDI_METAEVENT_TEXT:
00067 case MIDI_METAEVENT_COPYRIGHT:
00068 case MIDI_METAEVENT_TRACKNAME:
00069 case MIDI_METAEVENT_MAKER:
00070 event=new MetaTextEvent(deltaTime,type,metaData,length);
00071 break;
00072 case MIDI_METAEVENT_SETTEMPO:
00073 event=new MetaNumberEvent(deltaTime,type,metaData,length);
00074 break;
00075 default:
00076 event=new MetaGenericEvent(deltaTime,type,metaData,length);
00077 break;
00078 }
00079 _events.push_back(event);
00080 }
00081 break;
00082 case 0xF0:
00083 case 0xF7:
00084 {
00085 dword length=readNextVariableLength();
00086 byte sysData[length];
00087 for(int i=0;i<length;i++)
00088 {
00089 sysData[i]=readNextByte();
00090 }
00091 #warning "System Exclusive events are unimplemented"
00092
00093 }
00094 break;
00095 default:
00096 {
00097 byte command;
00098 int channel;
00099 byte param1;
00100 byte param2;
00101
00102 if((eventType>>7)==1)
00103 {
00104
00105
00106
00107
00108
00109
00110 command=(0xF0&eventType)>>4;
00111 channel=(int)(0x0F & eventType);
00112 param1=readNextByte();
00113 param2=readNextByte();
00114 }
00115 else
00116 {
00117
00118
00119
00120
00121
00122 command=lastMIDICommand;
00123 channel=lastChannel;
00124 param1=eventType;
00125 param2=readNextByte();
00126 }
00127
00128
00129 ChannelEvent *event=0;
00130 if(command==MIDI_CHEVENT_CONTROLLER)
00131 event=new ChannelControllerEvent(deltaTime,channel,param1,param2);
00132 else
00133 event=new ChannelEvent(deltaTime,command,channel,param1,param2);
00134
00135 _events.push_back(event);
00136
00137 lastMIDICommand=command;
00138 lastChannel=channel;
00139 }
00140 break;
00141 }
00142 }
00143 }
00144
00145 unsigned int Track::numEvents()
00146 {
00147 return _events.size();
00148 }
00149
00150 Event* Track::event(unsigned int id)
00151 {
00152 return _events[id];
00153 }
00154
00155 void Track::addEvent(Event* event)
00156 {
00157 _events.push_back(event);
00158 }
00159
00160 dword Track::readNextVariableLength()
00161 {
00162 dword result=0;
00163 bool flag=0;
00164 do
00165 {
00166 byte i=_data[_pos];
00167 dword contribution=(dword)(0x7F & i);
00168
00169 result=(result<<7);
00170 result+=contribution;
00171
00172 flag=(0x80 & i);
00173
00174 _pos++;
00175 } while(flag);
00176
00177 return result;
00178 }
00179
00180 byte Track::readNextByte()
00181 {
00182 byte result=_data[_pos];
00183 _pos++;
00184 return result;
00185 }
00186
00187 DataBuffer Track::data()
00188 {
00189 DataBuffer data(1000000);
00190
00191 byte lastCommand=MIDI_CHEVENT_INVALID;
00192
00193 for(int i=0;i<_events.size();i++)
00194 {
00195 DataBuffer eventData;
00196 if(_events[i]->type()==MIDI_CHEVENT)
00197 {
00198 ChannelEvent *chevent=(ChannelEvent*)_events[i];
00199 if(chevent->command()==lastCommand)
00200 eventData=chevent->data(true);
00201 else
00202 eventData=chevent->data(false);
00203
00204 lastCommand=chevent->command();
00205 }
00206 else
00207 eventData=_events[i]->data();
00208
00209 data.write(eventData);
00210 }
00211
00212 return data;
00213 }
00214 }