v 0. Pasted by Anonymous as cpp at 2016-09-14 03:19:25 MSK and set expiration to never.

Paste will expire never.

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <cmath>
  4. #include <ctime>
  5. #include <vector>
  6. #include <algorithm>
  7.  
  8. //==============================================================================
  9.  
  10. typedef signed char si8;
  11. typedef unsigned char ui8;
  12. typedef signed short si16;
  13. typedef unsigned short ui16;
  14. typedef signed int si32;
  15. typedef unsigned int ui32;
  16. typedef signed long long si64;
  17. typedef unsigned long long ui64;
  18.  
  19. using std::vector;
  20.  
  21. //==============================================================================
  22.  
  23. struct MIDIEvent
  24. {
  25.     ui32 delta;
  26.     ui32 data[3];
  27.     ui8 status;
  28. };
  29.  
  30. struct MIDITrack
  31. {
  32.     ui32 tag;
  33.     ui32 len;
  34.     vector<MIDIEvent> events;
  35. };
  36.  
  37. struct MIDI
  38. {
  39.     ui32 tag;
  40.     ui32 hdr_len;
  41.     ui16 format;
  42.     ui16 ntrks;
  43.     ui16 division;
  44.     vector<MIDITrack> tracks;
  45. };
  46.  
  47. struct NoteInfo
  48. {
  49.     ui32 start;
  50.     ui32 duration;
  51.     ui32 pitch;
  52.     ui32 velocity_on;
  53.     ui32 velocity_off;
  54.     ui32 preset;
  55.     ui32 channel;
  56. };
  57.  
  58. struct ByteStreamView
  59. {
  60.     const vector<ui8> *buf;
  61.     ui32 pos;
  62. };
  63.  
  64. //==============================================================================
  65.  
  66. const float pi=3.14159265358979f;
  67.  
  68. //==============================================================================
  69.  
  70. const char *instrument_names[128+1+47]={
  71. "Acoustic Grand Piano",
  72. "Bright Acoustic Piano",
  73. "Electric Grand Piano",
  74. "Honky-tonk Piano",
  75. "Electric Piano 1",
  76. "Electric Piano 2",
  77. "Harpsichord",
  78. "Clavinet",
  79. "Celesta",
  80. "Glockenspiel",
  81. "Music Box",
  82. "Vibraphone",
  83. "Marimba",
  84. "Xylophone",
  85. "Tubular Bells",
  86. "Dulcimer",
  87. "Drawbar Organ",
  88. "Percussive Organ",
  89. "Rock Organ",
  90. "Church Organ",
  91. "Reed Organ",
  92. "Accordion",
  93. "Harmonica",
  94. "Tango Accordion",
  95. "Acoustic Guitar (nylon)",
  96. "Acoustic Guitar (steel)",
  97. "Electric Guitar (jazz)",
  98. "Electric Guitar (clean)",
  99. "Electric Guitar (muted)",
  100. "Overdriven Guitar",
  101. "Distortion Guitar",
  102. "Guitar Harmonics",
  103. "Acoustic Bass",
  104. "Electric Bass (finger)",
  105. "Electric Bass (pick)",
  106. "Fretless Bass",
  107. "Slap Bass 1",
  108. "Slap Bass 2",
  109. "Synth Bass 1",
  110. "Synth Bass 2",
  111. "Violin",
  112. "Viola",
  113. "Cello",
  114. "Contrabass",
  115. "Tremolo Strings",
  116. "Pizzicato Strings",
  117. "Orchestral Harp",
  118. "Timpani",
  119. "String Ensemble 1",
  120. "String Ensemble 2",
  121. "Synth Strings 1",
  122. "Synth Strings 2",
  123. "Choir Aahs",
  124. "Voice Oohs",
  125. "Synth Choir",
  126. "Orchestra Hit",
  127. "Trumpet",
  128. "Trombone",
  129. "Tuba",
  130. "Muted Trumpet",
  131. "French Horn",
  132. "Brass Section",
  133. "Synth Brass 1",
  134. "Synth Brass 2",
  135. "Soprano Sax",
  136. "Alto Sax",
  137. "Tenor Sax",
  138. "Baritone Sax",
  139. "Oboe",
  140. "English Horn",
  141. "Bassoon",
  142. "Clarinet",
  143. "Piccolo",
  144. "Flute",
  145. "Recorder",
  146. "Pan Flute",
  147. "Blown bottle",
  148. "Shakuhachi",
  149. "Whistle",
  150. "Ocarina",
  151. "Lead 1 (square)",
  152. "Lead 2 (sawtooth)",
  153. "Lead 3 (calliope)",
  154. "Lead 4 chiff",
  155. "Lead 5 (charang)",
  156. "Lead 6 (voice)",
  157. "Lead 7 (fifths)",
  158. "Lead 8 (bass + lead)",
  159. "Pad 1 (new age)",
  160. "Pad 2 (warm)",
  161. "Pad 3 (polysynth)",
  162. "Pad 4 (choir)",
  163. "Pad 5 (bowed)",
  164. "Pad 6 (metallic)",
  165. "Pad 7 (halo)",
  166. "Pad 8 (sweep)",
  167. "FX 1 (rain)",
  168. "FX 2 (soundtrack)",
  169. "FX 3 (crystal)",
  170. "FX 4 (atmosphere)",
  171. "FX 5 (brightness)",
  172. "FX 6 (goblins)",
  173. "FX 7 (echoes)",
  174. "FX 8 (sci-fi)",
  175. "Sitar",
  176. "Banjo",
  177. "Shamisen",
  178. "Koto",
  179. "Kalimba",
  180. "Bagpipe",
  181. "Fiddle",
  182. "Shanai",
  183. "Tinkle Bell",
  184. "Agogo",
  185. "Steel Drums",
  186. "Woodblock",
  187. "Taiko Drum",
  188. "Melodic Tom",
  189. "Synth Drum",
  190. "Reverse Cymbal",
  191. "Guitar Fret Noise",
  192. "Breath Noise",
  193. "Seashore",
  194. "Bird Tweet",
  195. "Telephone Ring",
  196. "Helicopter",
  197. "Applause",
  198. "Gunshot",
  199. "Various percussion on channel 10",
  200. "Bass Drum 2",
  201. "Bass Drum 1",
  202. "Side Stick/Rimshot",
  203. "Snare Drum 1",
  204. "Hand Clap",
  205. "Snare Drum 2",
  206. "Low Tom 2",
  207. "Closed Hi-hat",
  208. "Low Tom 1",
  209. "Pedal Hi-hat",
  210. "Mid Tom 2",
  211. "Open Hi-hat",
  212. "Mid Tom 1",
  213. "High Tom 2",
  214. "Crash Cymbal 1",
  215. "High Tom 1",
  216. "Ride Cymbal 1",
  217. "Chinese Cymbal",
  218. "Ride Bell",
  219. "Tambourine",
  220. "Splash Cymbal",
  221. "Cowbell",
  222. "Crash Cymbal 2",
  223. "Vibra Slap",
  224. "Ride Cymbal 2",
  225. "High Bongo",
  226. "Low Bongo",
  227. "Mute High Conga",
  228. "Open High Conga",
  229. "Low Conga",
  230. "High Timbale",
  231. "Low Timbale",
  232. "High Agogo",
  233. "Low Agogo",
  234. "Cabasa",
  235. "Maracas",
  236. "Short Whistle",
  237. "Long Whistle",
  238. "Short Guiro",
  239. "Long Guiro",
  240. "Claves",
  241. "High Wood Block",
  242. "Low Wood Block",
  243. "Mute Cuica",
  244. "Open Cuica",
  245. "Mute Triangle",
  246. "Open Triangle"
  247. };
  248.  
  249. //==============================================================================
  250.  
  251. static const ui32 freq=44100;
  252.  
  253. static const ui64 time_units_per_second=1000; // 1 ms
  254.  
  255. //==============================================================================
  256.  
  257. static char input_filename[65536];
  258. static char output_filename[65536];
  259.  
  260. static vector<ui8> input_file;
  261.  
  262. static ui8 instrument_map[128];
  263.  
  264. static float global_volume=0.125f;
  265.  
  266. static bool dump_note_info=false;
  267.  
  268. //==============================================================================
  269.  
  270. static vector<ui8> read_file(const char *filename)
  271. {
  272.     vector<ui8> ret;
  273.     FILE *f=fopen(filename,"rb");
  274.     if(f)
  275.     {
  276.         fseek(f,0,SEEK_END);
  277.         long n=ftell(f);
  278.         rewind(f);
  279.         ret.resize(std::size_t(n),ui8(0));
  280.         fread(&(ret[0]),std::size_t(n),1,f);
  281.         fclose(f);
  282.     }
  283.     return ret;
  284. }
  285.  
  286. static bool write_file(const char *filename,const vector<float> &sound)
  287. {
  288.     FILE *f=fopen(filename,"wb");
  289.     if(f)
  290.     {
  291.         // Relies on little-endian.
  292.  
  293.         ui16 value16;
  294.         ui32 value32;
  295.  
  296.         vector<ui8> pcm;
  297.  
  298.         fwrite("RIFF",4,1,f);
  299.         value32=36+2*sound.size();
  300.         fwrite(&value32,4,1,f);
  301.         fwrite("WAVE",4,1,f);
  302.         fwrite("fmt ",4,1,f);
  303.         value32=16;
  304.         fwrite(&value32,4,1,f);
  305.         value16=1;
  306.         fwrite(&value16,2,1,f);
  307.         value16=2;
  308.         fwrite(&value16,2,1,f);
  309.         value32=freq;
  310.         fwrite(&value32,4,1,f);
  311.         value32=freq*4;
  312.         fwrite(&value32,4,1,f);
  313.         value16=4;
  314.         fwrite(&value16,2,1,f);
  315.         value16=16;
  316.         fwrite(&value16,2,1,f);
  317.         fwrite("data",4,1,f);
  318.         value32=2*sound.size();
  319.         fwrite(&value32,4,1,f);
  320.  
  321.         for(ui32 i=0,n=sound.size();i<n;++i)
  322.         {
  323.             float value=sound[i];
  324.             value=floorf(32757.0f*value+0.5f);
  325.             if(value<-32767.0f) value=-32767.0f;
  326.             if(value>+32767.0f) value=+32767.0f;
  327.             si16 sample=si16(value);
  328.             //fwrite(&sample,2,1,f);
  329.             pcm.push_back(ui8(ui16(sample)&0xFF));
  330.             pcm.push_back(ui8(ui16(sample)>>8));
  331.         }
  332.  
  333.         fwrite(pcm.data(),1,pcm.size(),f);
  334.  
  335.         fclose(f);
  336.         return true;
  337.     }
  338.     return false;
  339. }
  340.  
  341. //==============================================================================
  342.  
  343. static ui8 read_ui8(ByteStreamView &stream)
  344. {
  345.     if(stream.pos>=stream.buf->size()) return 0;
  346.     else return (*stream.buf)[stream.pos++];
  347. }
  348.  
  349. static ui16 read_ui16(ByteStreamView &stream)
  350. {
  351.     ui16 ret=0;
  352.     ret=ui16(ui16(ret<<8)|ui16(read_ui8(stream)));
  353.     ret=ui16(ui16(ret<<8)|ui16(read_ui8(stream)));
  354.     return ret;
  355. }
  356.  
  357. static ui32 read_ui32(ByteStreamView &stream)
  358. {
  359.     ui32 ret=0;
  360.     ret=(ret<<8)|ui32(read_ui8(stream));
  361.     ret=(ret<<8)|ui32(read_ui8(stream));
  362.     ret=(ret<<8)|ui32(read_ui8(stream));
  363.     ret=(ret<<8)|ui32(read_ui8(stream));
  364.     return ret;
  365. }
  366.  
  367. static ui64 read_tt(ByteStreamView &stream)
  368. {
  369.     ui64 ret=0;
  370.     ui8 b;
  371.     do{
  372.         b=read_ui8(stream);
  373.         ret=(ret<<7)+ui64(b&127);
  374.     } while(b>127);
  375.     return ret;
  376. }
  377.  
  378. static void read_header(ByteStreamView &stream,MIDI &midi)
  379. {
  380.     midi.tag=read_ui32(stream);
  381.     midi.hdr_len=read_ui32(stream);
  382.     midi.format=read_ui16(stream);
  383.     midi.ntrks=read_ui16(stream);
  384.     midi.division=read_ui16(stream);
  385.     for(si32 i=6;i<si32(midi.hdr_len);++i)
  386.         read_ui8(stream);
  387. }
  388.  
  389. static MIDITrack read_track(ByteStreamView &stream)
  390. {
  391.     MIDITrack ret;
  392.     ret.tag=read_ui32(stream);
  393.     ret.len=read_ui32(stream);
  394.     ui32 pos0=stream.pos;
  395.     ui8 status=0;
  396.  
  397.     while(stream.pos-pos0<ret.len)
  398.     {
  399.         MIDIEvent event;
  400.         ui8 b;
  401.         event.delta=ui32(read_tt(stream));
  402.         b=read_ui8(stream);
  403.         if(b>127)
  404.         {
  405.             event.status=b;
  406.             b=read_ui8(stream);
  407.         }
  408.         else event.status=status;
  409.         if(event.status>=128&&event.status<=239) status=event.status;
  410.  
  411.         switch(event.status>>4)
  412.         {
  413.             case 0x8: // NoteOFF
  414.                 event.data[0]=ui32(b); // pitch
  415.                 event.data[1]=ui32(read_ui8(stream)); // velocity
  416.                 break;
  417.             case 0x9: // NoteON
  418.                 event.data[0]=ui32(b); // pitch
  419.                 event.data[1]=ui32(read_ui8(stream)); // velocity
  420.                 break;
  421.             case 0xA: // KeyPressure
  422.                 event.data[0]=ui32(b); // key
  423.                 event.data[1]=ui32(read_ui8(stream)); // pressure
  424.                 break;
  425.             case 0xB: // ControllerChange
  426.                 event.data[0]=ui32(b); // controller
  427.                 event.data[1]=ui32(read_ui8(stream)); // value
  428.                 break;
  429.             case 0xC: // ProgramChange
  430.                 event.data[0]=ui32(b); // preset
  431.                 break;
  432.             case 0xD: // ChannelPressure
  433.                 event.data[0]=ui32(b); // pressure
  434.                 break;
  435.             case 0xE: // PitchBend
  436.                 event.data[0]=ui32(b); // bend
  437.                 event.data[0]+=ui32(read_ui8(stream))*128;
  438.                 break;
  439.             case 0xF:
  440.                 switch(event.status&15)
  441.                 {
  442.                     case 0: // SystemExclusive
  443.                         event.data[0]=b; // length
  444.                         event.data[1]=stream.pos; // message start
  445.                         for(ui32 k=0;k<event.data[0];++k)
  446.                             read_ui8(stream);
  447.                         status=0;
  448.                         break;
  449.                     case 2: // SongPosition
  450.                         event.data[0]=b; // pos
  451.                         event.data[0]+=ui32(read_ui8(stream))*128;
  452.                         break;
  453.                     case 3: // SongSelect
  454.                         event.data[0]=b; // song number
  455.                         break;
  456.                     case 5: // BusSelect
  457.                         event.data[0]=b; // bus number
  458.                         break;
  459.                     case 7: // EscapedEvent
  460.                         event.data[0]=b; // length
  461.                         event.data[1]=stream.pos; // message start
  462.                         for(ui32 k=0;k<event.data[0];++k)
  463.                             read_ui8(stream);
  464.                         status=0;
  465.                         break;
  466.                     case 15: // MetaEvent
  467.                         event.data[0]=b; // type
  468.                         event.data[1]=ui32(read_ui8(stream)); // length
  469.                         event.data[2]=stream.pos; // message
  470.                         for(ui32 k=0;k<event.data[1];++k)
  471.                             read_ui8(stream);
  472.                         break;
  473.                     default:
  474.                         printf("\nWARNING: unrecognized event type!\n");
  475.                         --stream.pos; // HACK
  476.                 }
  477.                 break;
  478.         }
  479.         ret.events.push_back(event);
  480.     }
  481.     return ret;
  482. }
  483.  
  484. static MIDI read_midi(ByteStreamView &stream)
  485. {
  486.     MIDI ret;
  487.     read_header(stream,ret);
  488.     for(ui32 i=0;i<ret.ntrks;++i)
  489.         ret.tracks.push_back(read_track(stream));
  490.     return ret;
  491. }
  492.  
  493. //==============================================================================
  494.  
  495. static vector<NoteInfo> exract_notes(const MIDI &midi)
  496. {
  497.     vector<NoteInfo> ret;
  498.  
  499.     // Possibly HACK.
  500.     ui64 pulses_per_second=(midi.division>0x7FFF?
  501.         ui64(256-ui32(midi.division>>8))*ui64(midi.division&0xFF):
  502.         ui64(120*midi.division/60));
  503.  
  504.     for(ui32 i=0;i<midi.ntrks;++i)
  505.     {
  506.         ui32 sig_num=4;
  507.         ui32 sig_den=4;
  508.         ui32 mtr_clk=24;
  509.         ui32 n32_qrt=8;
  510.  
  511.         const MIDITrack &track=midi.tracks[i];
  512.  
  513.         ui64 t=0; // in microseconds
  514.         si32 program[16];
  515.         si32 start[16][128];
  516.         si32 vel[16][128];
  517.  
  518.         for(ui32 j=0;j<16;++j)
  519.         {
  520.             program[j]=0;
  521.             for(ui32 k=0;k<128;++k)
  522.                 start[j][k]=-1;
  523.         }
  524.  
  525.         for(ui32 j=0;j<track.events.size();++j)
  526.         {
  527.             const MIDIEvent &event=track.events[j];
  528.             ui32 t_units=ui32(t*time_units_per_second/ui64(1000000));
  529.             switch(event.status>>4)
  530.             {
  531.                 case 0x8: // NoteOFF
  532.                 {
  533.                     ui32 channel=event.status&0xF;
  534.                     ui32 pitch=event.data[0];
  535.                     ui32 velocity=event.data[1];
  536.                     if(start[channel][pitch]>-1)
  537.                     {
  538.                         NoteInfo note;
  539.                         note.start=ui32(start[channel][pitch]);
  540.                         note.duration=t_units-note.start;
  541.                         note.pitch=pitch;
  542.                         note.channel=channel;
  543.                         note.preset=ui32(program[channel]);
  544.                         note.velocity_on=ui32(vel[channel][pitch]);
  545.                         note.velocity_off=velocity;
  546.                         ret.push_back(note);
  547.                     }
  548.                     start[channel][pitch]=-1;
  549.                     break;
  550.                 }
  551.                 case 0x9: // NoteON
  552.                 {
  553.                     ui32 channel=event.status&0xF;
  554.                     ui32 pitch=event.data[0];
  555.                     ui32 velocity=event.data[1];
  556.                     if(start[channel][pitch]>-1||velocity==0)
  557.                     {
  558.                         NoteInfo note;
  559.                         note.start=ui32(start[channel][pitch]);
  560.                         note.duration=t_units-note.start;
  561.                         note.pitch=pitch;
  562.                         note.channel=channel;
  563.                         note.preset=ui32(program[channel]);
  564.                         note.velocity_on=ui32(vel[channel][pitch]);
  565.                         note.velocity_off=64;
  566.                         ret.push_back(note);
  567.                         start[channel][pitch]=-1;
  568.                     }
  569.                     if(velocity>0)
  570.                     {
  571.                         start[channel][pitch]=si32(t_units);
  572.                         vel[channel][pitch]=si32(velocity);
  573.                     }
  574.                     break;
  575.                 }
  576.                 case 0xC: // Preset
  577.                 {
  578.                     ui32 channel=event.status&0xF;
  579.                     ui32 preset=event.data[0];
  580.  
  581.                     program[channel]=si32(preset);
  582.                 }
  583.                 case 0xF:
  584.                 {
  585.                     if(event.status==0xFF)
  586.                     {
  587.                         if(event.data[0]==0x51) // Tempo
  588.                         {
  589.                             ui32 tempo=ui32(
  590.                                 (input_file[event.data[2]+0]<<16)|
  591.                                 (input_file[event.data[2]+1]<< 8)|
  592.                                 (input_file[event.data[2]+2]<< 0));
  593.                             pulses_per_second=(midi.division>0x7FFF?
  594.                                 ui64(256-ui32(midi.division>>8))*ui64(midi.division&0xFF):
  595.                                 ui64(1000000)*ui64(midi.division)/ui64(tempo));
  596.                         }
  597.  
  598.                         if(event.data[0]==0x58) // Time signature
  599.                         {
  600.                             sig_num=input_file[event.data[2]+0];
  601.                             sig_den=input_file[event.data[2]+1];
  602.                             mtr_clk=input_file[event.data[2]+2];
  603.                             n32_qrt=input_file[event.data[2]+3];
  604.                             (void)sig_num;
  605.                             (void)sig_den;
  606.                             (void)mtr_clk;
  607.                             (void)n32_qrt;
  608.                         }
  609.                     }
  610.                 }
  611.             }
  612.             t+=ui64(1000000)*ui64(event.delta)/pulses_per_second;
  613.         }
  614.  
  615.         for(ui32 channel=0;channel<16;++channel)
  616.         {
  617.             for(ui32 pitch=0;pitch<128;++pitch)
  618.                 if(start[channel][pitch]>-1)
  619.                 {
  620.                     ui32 t_units=ui32(t*time_units_per_second/ui64(1000000));
  621.                     NoteInfo note;
  622.                     note.start=ui32(start[channel][pitch]);
  623.                     note.duration=t_units-note.start;
  624.                     note.pitch=pitch;
  625.                     note.channel=channel;
  626.                     note.preset=ui32(program[channel]);
  627.                     note.velocity_on=ui32(vel[channel][pitch]);
  628.                     note.velocity_off=64;
  629.                     ret.push_back(note);
  630.                 }
  631.         }
  632.     }
  633.  
  634.     return ret;
  635. }
  636.  
  637. // In seconds, rounded up.
  638. static ui32 get_duration(const vector<NoteInfo> &notes)
  639. {
  640.     ui32 ret=0;
  641.     for(ui32 i=0,n=notes.size();i<n;++i)
  642.     {
  643.         const NoteInfo &note=notes[i];
  644.         ui32 t=note.start+note.duration;
  645.         if(t>ret) ret=t;
  646.     }
  647.     ret=ui32((ret+time_units_per_second-1)/time_units_per_second);
  648.     return ret;
  649. }
  650.  
  651. //==============================================================================
  652.  
  653. static void get_instrument_list(
  654.     const vector<NoteInfo> &notes,
  655.     bool (&dst)[128+1+47])
  656. {
  657.     for(ui32 i=0;i<sizeof(dst);++i)
  658.         dst[i]=false;
  659.     for(ui32 i=0,n=notes.size();i<n;++i)
  660.     {
  661.         const NoteInfo &note=notes[i];
  662.         if(note.channel!=9)
  663.             dst[note.preset]=true;
  664.         else
  665.         {
  666.             dst[128]=true;
  667.             if(note.pitch>=35&&note.pitch<35+47)
  668.                 dst[129+note.pitch-35]=true;
  669.         }
  670.     }
  671. }
  672.  
  673. //==============================================================================
  674.  
  675. static void dump_notes(const vector<NoteInfo> &notes)
  676. {
  677.     printf("Note information (time unit: 1/%lu s):\n",
  678.         (unsigned long)(time_units_per_second));
  679.     printf("\n");
  680.     printf("     Start|  Duration| Pitch| On| Off|Preset|Channel\n");
  681.     printf("----------+----------+------+---+----+------+-------\n");
  682.     for(ui32 i=0,n=notes.size();i<n;++i)
  683.     {
  684.         const NoteInfo &note=notes[i];
  685.  
  686.         printf("%10lu|%10lu|%6lu|%3lu| %3lu|%6lu|%7lu\n",
  687.             (unsigned long)(note.start),
  688.             (unsigned long)(note.duration),
  689.             (unsigned long)(note.pitch),
  690.             (unsigned long)(note.velocity_on),
  691.             (unsigned long)(note.velocity_off),
  692.             (unsigned long)(note.preset),
  693.             (unsigned long)(note.channel));
  694.     }
  695. }
  696.  
  697. //==============================================================================
  698.  
  699. static void print_midi_info(const MIDI &midi)
  700. {
  701.     printf("  Tag: %c%c%c%c [%08X]\n",
  702.         (midi.tag>>24)&0xFF,
  703.         (midi.tag>>16)&0xFF,
  704.         (midi.tag>>8)&0xFF,
  705.         (midi.tag>>0)&0xFF,
  706.         midi.tag);
  707.     printf("  Header length: %u\n",midi.hdr_len);
  708.     printf("  Format: %u\n",midi.format);
  709.     printf("  Number of tracks: %u\n",ui32(midi.ntrks));
  710.     printf("  Division: %u\n",ui32(midi.division));
  711.     for(ui32 i=0;i<midi.ntrks;++i)
  712.     {
  713.         printf("    Track %d:\n",i);
  714.             printf("      Tag: %c%c%c%c [%08X]\n",
  715.                 (midi.tracks[i].tag>>24)&0xFF,
  716.                 (midi.tracks[i].tag>>16)&0xFF,
  717.                 (midi.tracks[i].tag>>8)&0xFF,
  718.                 (midi.tracks[i].tag>>0)&0xFF,
  719.                 midi.tracks[i].tag);
  720.         printf("      Size: %d bytes\n",midi.tracks[i].len);
  721.         printf("      Events: %d\n",midi.tracks[i].events.size());
  722.     }
  723. }
  724.  
  725. //==============================================================================
  726.  
  727. static float get_note_volume(ui32 pitch,ui32 velocity)
  728. {
  729.     return global_volume*(float(velocity)/127.0f)*powf(2.0f,-float(pitch)/64.0f);
  730. }
  731.  
  732. static float get_note_freq(ui32 pitch,ui32 velocity)
  733. {
  734.     (void)velocity;
  735.     return 440.0f*powf(2.0f,(float(pitch)-69.0f)/12.0f);
  736. }
  737.  
  738. //==============================================================================
  739. static const ui32 LOG2_WAVEFORM_TABLE_SIZE=10;
  740. static const ui32 WAVEFORM_TABLE_SIZE=1<<LOG2_WAVEFORM_TABLE_SIZE;
  741.  
  742. float snd_table_cosine[WAVEFORM_TABLE_SIZE];
  743. float snd_table_piano0[WAVEFORM_TABLE_SIZE];
  744. float snd_table_piano1[WAVEFORM_TABLE_SIZE];
  745. float snd_table_dulcimer0[WAVEFORM_TABLE_SIZE];
  746. float snd_table_dulcimer1[WAVEFORM_TABLE_SIZE];
  747. float snd_table_organ[WAVEFORM_TABLE_SIZE];
  748. float snd_table_violin0[WAVEFORM_TABLE_SIZE];
  749. float snd_table_violin1[WAVEFORM_TABLE_SIZE];
  750. float snd_table_brass[WAVEFORM_TABLE_SIZE];
  751. float snd_table_trumpet[WAVEFORM_TABLE_SIZE];
  752. float snd_table_glockenspiel0[WAVEFORM_TABLE_SIZE];
  753. float snd_table_glockenspiel1[WAVEFORM_TABLE_SIZE];
  754. float snd_table_ocarina0[WAVEFORM_TABLE_SIZE];
  755. float snd_table_ocarina1[WAVEFORM_TABLE_SIZE];
  756.  
  757. //==============================================================================
  758.  
  759. static void gen_waveform_table_from_harmonics(
  760.     float *table,
  761.     const vector<float> &harmonics)
  762. {
  763.     ui32 m=harmonics.size();
  764.  
  765.     for(ui32 i=0;i<WAVEFORM_TABLE_SIZE;++i)
  766.     {
  767.         float t=float(i)/float(WAVEFORM_TABLE_SIZE);
  768.         float x=2.0f*pi*t;
  769.         float y=0.0f;
  770.         for(ui32 j=0;j<m;++j)
  771.             y+=harmonics[j]*cosf(float(j)*x);
  772.         table[i]=y;
  773.     }
  774. }
  775.  
  776. template<typename F>
  777. static void gen_waveform_table_from_function(
  778.     float *table,
  779.     const F &f)
  780. {
  781.     for(ui32 i=0;i<WAVEFORM_TABLE_SIZE;++i)
  782.     {
  783.         float t=float(i)/float(WAVEFORM_TABLE_SIZE);
  784.         table[i]=f(t);
  785.     }
  786. }
  787.  
  788. //==============================================================================
  789.  
  790. static void init_tables()
  791. {
  792.     float a;
  793.  
  794.     float dB=powf(10.0f,0.05f); // Amplitude, not power.
  795.  
  796.     gen_waveform_table_from_harmonics(
  797.         snd_table_cosine,
  798.         {0.0f,1.0f});
  799.  
  800.     a=0.5f/powf(dB,-27.8f);
  801.     gen_waveform_table_from_harmonics(
  802.         snd_table_piano0,
  803.         {
  804.             0.0f,
  805.             a*powf(dB,-27.8f),
  806.             a*powf(dB,-31.1f),
  807.             a*powf(dB,-43.3f),
  808.             a*powf(dB,-43.4f),
  809.             a*powf(dB,-59.7f),
  810.             a*powf(dB,-62.0f),
  811.             a*powf(dB,-66.4f),
  812.             a*powf(dB,-80.5f)});
  813.  
  814.     a=0.5f/powf(dB,-43.7f);
  815.     gen_waveform_table_from_harmonics(
  816.         snd_table_piano1,
  817.         {
  818.             0.0f,
  819.             a*powf(dB,-43.7f),
  820.             a*powf(dB,-43.1f),
  821.             a*powf(dB,-53.6f),
  822.             a*powf(dB,-68.0f),
  823.             a*powf(dB,-79.2f),
  824.             a*powf(dB,-80.3f),
  825.             a*powf(dB,-77.7f),
  826.             a*powf(dB,-87.2f)});
  827.  
  828.     gen_waveform_table_from_function(
  829.         snd_table_dulcimer0,
  830.         [](float x)->float
  831.         {
  832.             float y=0.0f;
  833.             y+=0.5f*sinf(1.0f*2.0f*pi*x);
  834.             y+=0.125f*sinf(2.0f*2.0f*pi*x);
  835.             y+=0.25f*sinf(3.0f*2.0f*pi*x);
  836.             for(int i=4;i<=25;++i)
  837.                 y+=(1.0f+0.25f*sinf(7.3f*float(i)))*sinf(float(i)*2.0f*pi*x)/powf(2.0f,3.0f+float(i)/2.5f);
  838.             return y;
  839.         });
  840.  
  841.     gen_waveform_table_from_function(
  842.         snd_table_dulcimer1,
  843.         [](float x)->float
  844.         {
  845.             float y=0.0f;
  846.             y+=0.5f*sinf(1.0f*2.0f*pi*x);
  847.             y+=(1.0f/32.0f)*sinf(2.0f*2.0f*pi*x);
  848.             y+=0.125f*sinf(3.0f*2.0f*pi*x);
  849.             for(int i=4;i<=25;++i)
  850.                 y+=(1.0f+0.25f*sinf(7.3f*float(i)))*sinf(float(i)*2.0f*pi*x)/powf(2.0f,3.0f+float(i)/1.25f);
  851.             return y;
  852.         });
  853.  
  854.     gen_waveform_table_from_function(
  855.         snd_table_organ,
  856.         [](float x)->float
  857.         {
  858.             float y=0.0f;
  859.             y+=0.75f*sinf(1.0f*2.0f*pi*x);
  860.             y+=0.125f*sinf(2.0f*2.0f*pi*x);
  861.             y+=0.25f*sinf(3.0f*2.0f*pi*x);
  862.             y+=(1.0f/32.0f)*sinf(4.0f*2.0f*pi*x);
  863.             y+=(1.0f/16.0f)*sinf(5.0f*2.0f*pi*x);
  864.             for(int i=7;i<=37;i+=2)
  865.                 y+=sinf(float(i)*2.0f*pi*x)/(32.0f*float(i));
  866.             return y;
  867.         });
  868.  
  869.     gen_waveform_table_from_function(
  870.         snd_table_violin0,
  871.         [](float x)->float
  872.         {
  873.             float y=0.0f;
  874.             y+=0.5f*sinf(1.0f*2.0f*pi*x);
  875.             y+=0.125f*sinf(2.0f*2.0f*pi*x);
  876.             y+=0.075f*sinf(3.0f*2.0f*pi*x);
  877.             y+=0.125f*sinf(4.0f*2.0f*pi*x);
  878.             y+=0.125f*sinf(5.0f*2.0f*pi*x);
  879.             y+=0.375f*sinf(6.0f*2.0f*pi*x);
  880.             for(int i=7;i<=37;++i)
  881.                 y+=sinf(float(i)*2.0f*pi*x)/powf(2.0f,3.0f+float(i)/2.5f);
  882.             return y;
  883.         });
  884.  
  885.     gen_waveform_table_from_harmonics(
  886.         snd_table_violin1,
  887.         {
  888.             0.0f,
  889.             0.0f,
  890.             0.0f,
  891.             0.0f,
  892.             0.125f,
  893.             0.125f,
  894.             0.0f
  895.         });
  896.  
  897.     gen_waveform_table_from_function(
  898.         snd_table_brass,
  899.         [](float x)
  900.         {
  901.             return powf(fabsf(sinf(2.0f*pi*x)),80.0f);
  902.         });
  903.  
  904.     gen_waveform_table_from_function(
  905.         snd_table_trumpet,
  906.         [](float x)->float
  907.         {
  908.             const float dB=powf(10.0f,0.05f); // Amplitude, not power.
  909.             const float a=1.0f/powf(dB,-5.0f);
  910.  
  911.             float y=0.0f;
  912.             y+=a*powf(dB,-12.5f)*sinf(1.0f*2.0f*pi*x);
  913.             y+=a*powf(dB,-7.4f)*sinf(2.0f*2.0f*pi*x);
  914.             y+=a*powf(dB,-6.1f)*sinf(3.0f*2.0f*pi*x);
  915.  
  916.             for(int i=4;i<=15;++i)
  917.                 y+=(1.0f+0.125f*sinf(17.0f*float(i)))*powf(dB,-8.7f-5.37f*float(i))*sinf(float(i)*2.0f*pi*x);
  918.             return y;
  919.         });
  920.  
  921.     gen_waveform_table_from_function(
  922.         snd_table_glockenspiel0,
  923.         [](float x)
  924.         {
  925.             return
  926.                 0.125f*sinf(3.0f*2.0f*pi*x)+
  927.                 1.0f*sinf(12.0f*2.0f*pi*x);
  928.         });
  929.  
  930.     gen_waveform_table_from_function(
  931.         snd_table_glockenspiel1,
  932.         [](float x)
  933.         {
  934.             return
  935.                 0.03125f*sinf(5.0f*2.0f*pi*x)+
  936.                 1.0f*sinf(7.0f*2.0f*pi*x)+
  937.                 1.0f*sinf(16.0f*2.0f*pi*x)+
  938.                 0.125f*sinf(18.0f*2.0f*pi*x)+
  939.                 0.25f*sinf(23.0f*2.0f*pi*x);
  940.         });
  941.  
  942.     gen_waveform_table_from_function(
  943.         snd_table_ocarina0,
  944.         [](float x)
  945.         {
  946.             float dB=powf(10.0f,0.05f); // Amplitude, not power.
  947.             float a=1.0f/powf(dB,+6.0f);
  948.             return
  949.                 a*powf(dB,+6.0f)*sinf(1.0f*2.0f*pi*x)+
  950.                 a*powf(dB,-45.8f)*sinf(4.0f*2.0f*pi*x)+
  951.                 a*powf(dB,-44.9f)*sinf(6.0f*2.0f*pi*x)+
  952.                 a*powf(dB,-51.3f)*sinf(9.0f*2.0f*pi*x)+
  953.                 a*powf(dB,-53.1f)*sinf(11.0f*2.0f*pi*x)+
  954.                 a*powf(dB,-51.3f)*sinf(14.0f*2.0f*pi*x)+
  955.                 a*powf(dB,-55.7f)*sinf(16.0f*2.0f*pi*x)+
  956.                 a*powf(dB,-55.7f)*sinf(20.0f*2.0f*pi*x)+
  957.                 a*powf(dB,-58.5f)*sinf(22.0f*2.0f*pi*x)+
  958.                 a*powf(dB,-58.7f)*sinf(23.0f*2.0f*pi*x)+
  959.                 a*powf(dB,-53.1f)*sinf(25.0f*2.0f*pi*x)+
  960.                 a*powf(dB,-53.7f)*sinf(27.0f*2.0f*pi*x)+
  961.                 a*powf(dB,-62.5f)*sinf(31.0f*2.0f*pi*x)+
  962.                 a*powf(dB,-64.3f)*sinf(35.0f*2.0f*pi*x);
  963.         });
  964.  
  965.     gen_waveform_table_from_function(
  966.         snd_table_ocarina1,
  967.         [](float x)
  968.         {
  969.             float dB=powf(10.0f,0.05f); // Amplitude, not power.
  970.             float a=1.0f/powf(dB,+6.0f);
  971.             return
  972.                 a*powf(dB,+6.0f)*sinf(1.0f*2.0f*pi*x)+
  973.                 a*powf(dB,-48.0f)*sinf(2.0f*2.0f*pi*x)+
  974.                 a*powf(dB,-55.0f)*sinf(3.0f*2.0f*pi*x)+
  975.                 a*powf(dB,-59.0f)*sinf(4.0f*2.0f*pi*x)+
  976.                 a*powf(dB,-62.0f)*sinf(5.0f*2.0f*pi*x)+
  977.                 a*powf(dB,-61.2f)*sinf(9.0f*2.0f*pi*x)+
  978.                 a*powf(dB,-65.3f)*sinf(11.0f*2.0f*pi*x)+
  979.                 a*powf(dB,-51.3f)*sinf(23.0f*2.0f*pi*x)+
  980.                 a*powf(dB,-52.5f)*sinf(25.0f*2.0f*pi*x)+
  981.                 a*powf(dB,-64.2f)*sinf(29.0f*2.0f*pi*x)+
  982.                 a*powf(dB,-64.6f)*sinf(31.0f*2.0f*pi*x)+
  983.                 a*powf(dB,-66.7f)*sinf(35.0f*2.0f*pi*x)+
  984.                 a*powf(dB,-65.8f)*sinf(39.0f*2.0f*pi*x);
  985.         });
  986. }
  987.  
  988. //==============================================================================
  989.  
  990. template<typename Fn>
  991. static void add_note_adsr_sine(
  992.     vector<float> &buffer,
  993.     ui32 i0,
  994.     ui32 i1,
  995.     ui32 pitch,
  996.     ui32 velocity_on,
  997.     ui32 velocity_off,
  998.     float A,
  999.     float D,
  1000.     float S,
  1001.     float R0, // during sustain
  1002.     float R1, // release proper
  1003.     float G,
  1004.     float a0,
  1005.     const Fn &fn)
  1006. {
  1007.     (void)velocity_off;
  1008.  
  1009.     ui32 snd_len=buffer.size()/2;
  1010.  
  1011.     ui32 i0a=i0+ui32(A*float(freq));
  1012.  
  1013.     if(i0a>i1) i1=i0a;
  1014.  
  1015.     ui32 i2=i1+ui32(R1*float(freq));
  1016.     ui32 i1f=i1+7*(i2-i1)/8;
  1017.  
  1018.     if(i0a>snd_len) i0a=snd_len;
  1019.     if(i1>snd_len) i1=snd_len;
  1020.     if(i1f>snd_len) i1f=snd_len;
  1021.     if(i2>snd_len) i2=snd_len;
  1022.  
  1023.     const float C=2.5f;
  1024.  
  1025.     float dt=1.0f/float(freq);
  1026.  
  1027.     float a=a0*get_note_volume(pitch,velocity_on);
  1028.     float f=get_note_freq(pitch,velocity_on);
  1029.     float omega=2.0f*pi*f;
  1030.  
  1031.     float cS=1.0f-S;
  1032.  
  1033.     float P,Q;
  1034.     float p,q;
  1035.  
  1036.     float w,mw,dw,wd,mwd;
  1037.     float g,mg;
  1038.  
  1039.     if(G>0.0f)
  1040.     {
  1041.         g=1.0f;
  1042.         mg=expf(-(C/G)*dt);
  1043.  
  1044.         P=2.0f*cosf(-omega*dt);Q=1.0f;
  1045.         p=1.0f;q=P/2.0f;
  1046.  
  1047.         // Attack
  1048.         w=1.0f;
  1049.         mw=expf(-(C/A)*dt);
  1050.         for(ui32 i=i0;i<i0a;++i)
  1051.         {
  1052.             float value=fn(p,g);
  1053.             value=a*(1.0f-w)*value;
  1054.             float r=P*p-q;q=p;p=r;
  1055.             buffer[2*i+0]+=value;
  1056.             buffer[2*i+1]+=value;
  1057.             w*=mw;
  1058.             g*=mg;
  1059.         }
  1060.  
  1061.         // Decay/sustain
  1062.         a=a*(1.0f-w);
  1063.  
  1064.         if(R0>0.0f)
  1065.         {
  1066.             w=1.0f;
  1067.             mw=expf(-(C/R0)*dt);
  1068.             wd=1.0f;
  1069.             mwd=expf(-(C/D)*dt);
  1070.  
  1071.             if(S!=1.0f)
  1072.             {
  1073.                 for(ui32 i=i0a;i<i1;++i)
  1074.                 {
  1075.                     float value=fn(p,g);
  1076.                     value=a*(S+cS*wd)*w*value;
  1077.                     float r=P*p-q;q=Q*p;p=r;
  1078.                     buffer[2*i+0]+=value;
  1079.                     buffer[2*i+1]+=value;
  1080.                     w*=mw;
  1081.                     wd*=mwd;
  1082.                     g*=mg;
  1083.                 }
  1084.             }
  1085.             else
  1086.             {
  1087.                 for(ui32 i=i0a;i<i1;++i)
  1088.                 {
  1089.                     float value=fn(p,g);
  1090.                     value=a*w*value;
  1091.                     float r=P*p-q;q=Q*p;p=r;
  1092.                     buffer[2*i+0]+=value;
  1093.                     buffer[2*i+1]+=value;
  1094.                     w*=mw;
  1095.                     g*=mg;
  1096.                 }
  1097.             }
  1098.         }
  1099.         else
  1100.         {
  1101.             w=1.0f;
  1102.             mw=1.0f; // mw=expf(-(C/R0)*dt);
  1103.             wd=1.0f;
  1104.             mwd=expf(-(C/D)*dt);
  1105.  
  1106.             if(S!=1.0f)
  1107.             {
  1108.                 for(ui32 i=i0a;i<i1;++i)
  1109.                 {
  1110.                     float value=fn(p,g);
  1111.                     value=a*(S+cS*wd)*value;
  1112.                     float r=P*p-q;q=Q*p;p=r;
  1113.                     buffer[2*i+0]+=value;
  1114.                     buffer[2*i+1]+=value;
  1115.                     wd*=mwd;
  1116.                     g*=mg;
  1117.                 }
  1118.             }
  1119.             else
  1120.             {
  1121.                 for(ui32 i=i0a;i<i1;++i)
  1122.                 {
  1123.                     float value=fn(p,g);
  1124.                     value=a*value;
  1125.                     float r=P*p-q;q=Q*p;p=r;
  1126.                     buffer[2*i+0]+=value;
  1127.                     buffer[2*i+1]+=value;
  1128.                     g*=mg;
  1129.                 }
  1130.             }
  1131.         }
  1132.  
  1133.         // Release
  1134.         a=a*(S+cS*wd)*w;
  1135.         w=1.0f;
  1136.         mw=expf(-(C/R1)*dt);
  1137.         for(ui32 i=i1;i<i1f;++i)
  1138.         {
  1139.             float value=fn(p,g);
  1140.             value=a*w*value;
  1141.             float r=P*p-q;q=Q*p;p=r;
  1142.             buffer[2*i+0]+=value;
  1143.             buffer[2*i+1]+=value;
  1144.             w*=mw;
  1145.             g*=mg;
  1146.         }
  1147.  
  1148.         // Fade
  1149.         w=a*w;
  1150.  
  1151.         dw=-w/float(i2-i1f);
  1152.         for(ui32 i=i1f;i<i2;++i)
  1153.         {
  1154.             float value=fn(p,g);
  1155.             value=w*value;
  1156.             float r=P*p-q;q=Q*p;p=r;
  1157.             buffer[2*i+0]+=value;
  1158.             buffer[2*i+1]+=value;
  1159.             w+=dw;
  1160.             g*=mg;
  1161.         }
  1162.     }
  1163.     else
  1164.     {
  1165.         g=1.0f;
  1166.         mg=1.0f;
  1167.  
  1168.         P=2.0f*cosf(-omega*dt);Q=1.0f;
  1169.         p=1.0f;q=P/2.0f;
  1170.  
  1171.         // Attack
  1172.         w=1.0f;
  1173.         mw=expf(-(C/A)*dt);
  1174.         for(ui32 i=i0;i<i0a;++i)
  1175.         {
  1176.             float value=fn(p,g);
  1177.             value=a*(1.0f-w)*value;
  1178.             float r=P*p-q;q=p;p=r;
  1179.             buffer[2*i+0]+=value;
  1180.             buffer[2*i+1]+=value;
  1181.             w*=mw;
  1182.         }
  1183.  
  1184.         // Decay/sustain
  1185.         a=a*(1.0f-w);
  1186.  
  1187.         if(R0>0.0f)
  1188.         {
  1189.             w=1.0f;
  1190.             mw=expf(-(C/R0)*dt);
  1191.             wd=1.0f;
  1192.             mwd=expf(-(C/D)*dt);
  1193.  
  1194.             if(S!=1.0f)
  1195.             {
  1196.                 for(ui32 i=i0a;i<i1;++i)
  1197.                 {
  1198.                     float value=fn(p,g);
  1199.                     value=a*(S+cS*wd)*w*value;
  1200.                     float r=P*p-q;q=Q*p;p=r;
  1201.                     buffer[2*i+0]+=value;
  1202.                     buffer[2*i+1]+=value;
  1203.                     w*=mw;
  1204.                     wd*=mwd;
  1205.                 }
  1206.             }
  1207.             else
  1208.             {
  1209.                 for(ui32 i=i0a;i<i1;++i)
  1210.                 {
  1211.                     float value=fn(p,g);
  1212.                     value=a*w*value;
  1213.                     float r=P*p-q;q=Q*p;p=r;
  1214.                     buffer[2*i+0]+=value;
  1215.                     buffer[2*i+1]+=value;
  1216.                     w*=mw;
  1217.                 }
  1218.             }
  1219.         }
  1220.         else
  1221.         {
  1222.             w=1.0f;
  1223.             mw=1.0f; // mw=expf(-(C/R0)*dt);
  1224.             wd=1.0f;
  1225.             mwd=expf(-(C/D)*dt);
  1226.  
  1227.             if(S!=1.0f)
  1228.             {
  1229.                 for(ui32 i=i0a;i<i1;++i)
  1230.                 {
  1231.                     float value=fn(p,g);
  1232.                     value=a*(S+cS*wd)*value;
  1233.                     float r=P*p-q;q=Q*p;p=r;
  1234.                     buffer[2*i+0]+=value;
  1235.                     buffer[2*i+1]+=value;
  1236.                     wd*=mwd;
  1237.                 }
  1238.             }
  1239.             else
  1240.             {
  1241.                 for(ui32 i=i0a;i<i1;++i)
  1242.                 {
  1243.                     float value=fn(p,g);
  1244.                     value=a*value;
  1245.                     float r=P*p-q;q=Q*p;p=r;
  1246.                     buffer[2*i+0]+=value;
  1247.                     buffer[2*i+1]+=value;
  1248.                 }
  1249.             }
  1250.         }
  1251.  
  1252.         // Release
  1253.         a=a*(S+cS*wd)*w;
  1254.         w=1.0f;
  1255.         mw=expf(-(C/R1)*dt);
  1256.         for(ui32 i=i1;i<i1f;++i)
  1257.         {
  1258.             float value=fn(p,g);
  1259.             value=a*w*value;
  1260.             float r=P*p-q;q=Q*p;p=r;
  1261.             buffer[2*i+0]+=value;
  1262.             buffer[2*i+1]+=value;
  1263.             w*=mw;
  1264.         }
  1265.  
  1266.         // Fade
  1267.         w=a*w;
  1268.  
  1269.         dw=-w/float(i2-i1f);
  1270.         for(ui32 i=i1f;i<i2;++i)
  1271.         {
  1272.             float value=fn(p,g);
  1273.             value=w*value;
  1274.             float r=P*p-q;q=Q*p;p=r;
  1275.             buffer[2*i+0]+=value;
  1276.             buffer[2*i+1]+=value;
  1277.             w+=dw;
  1278.         }
  1279.     }
  1280. }
  1281.  
  1282. template<typename Fn>
  1283. static void add_note_adsr_index(
  1284.     vector<float> &buffer,
  1285.     ui32 i0,
  1286.     ui32 i1,
  1287.     ui32 pitch,
  1288.     ui32 velocity_on,
  1289.     ui32 velocity_off,
  1290.     float A,
  1291.     float D,
  1292.     float S,
  1293.     float R0, // during sustain
  1294.     float R1, // release proper
  1295.     float G,
  1296.     float a0,
  1297.     float f0,
  1298.     const Fn &fn)
  1299. {
  1300.     (void)velocity_off;
  1301.  
  1302.     ui32 snd_len=buffer.size()/2;
  1303.  
  1304.     ui32 i0a=i0+ui32(A*float(freq));
  1305.  
  1306.     if(i0a>i1) i1=i0a;
  1307.  
  1308.     ui32 i2=i1+ui32(R1*float(freq));
  1309.     ui32 i1f=i1+7*(i2-i1)/8;
  1310.  
  1311.     if(i0a>snd_len) i0a=snd_len;
  1312.     if(i1>snd_len) i1=snd_len;
  1313.     if(i1f>snd_len) i1f=snd_len;
  1314.     if(i2>snd_len) i2=snd_len;
  1315.  
  1316.     const float C=2.5f;
  1317.  
  1318.     float dt=1.0f/float(freq);
  1319.  
  1320.     float a=a0*get_note_volume(pitch,velocity_on);
  1321.     float f=f0*get_note_freq(pitch,velocity_on);
  1322.     ui32 idx=0;
  1323.     ui32 di=ui32(4294967296.0f*f*dt);
  1324.  
  1325.     float cS=1.0f-S;
  1326.  
  1327.     float w,mw,dw,wd,mwd;
  1328.     float g,mg;
  1329.  
  1330.     if(G>0.0f)
  1331.     {
  1332.         g=1.0f;
  1333.         mg=expf(-(C/G)*dt);
  1334.  
  1335.         // Attack
  1336.         w=1.0f;
  1337.         mw=expf(-(C/A)*dt);
  1338.         for(ui32 i=i0;i<i0a;++i)
  1339.         {
  1340.             float value=fn(idx,g);
  1341.             value=a*(1.0f-w)*value;
  1342.             idx+=di;
  1343.             buffer[2*i+0]+=value;
  1344.             buffer[2*i+1]+=value;
  1345.             w*=mw;
  1346.             g*=mg;
  1347.         }
  1348.  
  1349.         // Decay/sustain
  1350.         a=a*(1.0f-w);
  1351.  
  1352.         if(R0>0.0f)
  1353.         {
  1354.             w=1.0f;
  1355.             mw=expf(-(C/R0)*dt);
  1356.             wd=1.0f;
  1357.             mwd=expf(-(C/D)*dt);
  1358.  
  1359.             if(S!=1.0f)
  1360.             {
  1361.                 for(ui32 i=i0a;i<i1;++i)
  1362.                 {
  1363.                     float value=fn(idx,g);
  1364.                     value=a*(S+cS*wd)*w*value;
  1365.                     idx+=di;
  1366.                     buffer[2*i+0]+=value;
  1367.                     buffer[2*i+1]+=value;
  1368.                     w*=mw;
  1369.                     wd*=mwd;
  1370.                     g*=mg;
  1371.                 }
  1372.             }
  1373.             else
  1374.             {
  1375.                 for(ui32 i=i0a;i<i1;++i)
  1376.                 {
  1377.                     float value=fn(idx,g);
  1378.                     value=a*w*value;
  1379.                     idx+=di;
  1380.                     buffer[2*i+0]+=value;
  1381.                     buffer[2*i+1]+=value;
  1382.                     w*=mw;
  1383.                     g*=mg;
  1384.                 }
  1385.             }
  1386.         }
  1387.         else
  1388.         {
  1389.             w=1.0f;
  1390.             mw=1.0f; // mw=expf(-(C/R0)*dt);
  1391.             wd=1.0f;
  1392.             mwd=expf(-(C/D)*dt);
  1393.  
  1394.             if(S!=1.0f)
  1395.             {
  1396.                 for(ui32 i=i0a;i<i1;++i)
  1397.                 {
  1398.                     float value=fn(idx,g);
  1399.                     value=a*(S+cS*wd)*value;
  1400.                     idx+=di;
  1401.                     buffer[2*i+0]+=value;
  1402.                     buffer[2*i+1]+=value;
  1403.                     wd*=mwd;
  1404.                     g*=mg;
  1405.                 }
  1406.             }
  1407.             else
  1408.             {
  1409.                 for(ui32 i=i0a;i<i1;++i)
  1410.                 {
  1411.                     float value=fn(idx,g);
  1412.                     value=a*value;
  1413.                     idx+=di;
  1414.                     buffer[2*i+0]+=value;
  1415.                     buffer[2*i+1]+=value;
  1416.                     g*=mg;
  1417.                 }
  1418.             }
  1419.         }
  1420.  
  1421.         // Release
  1422.         a=a*(S+cS*wd)*w;
  1423.         w=1.0f;
  1424.         mw=expf(-(C/R1)*dt);
  1425.         for(ui32 i=i1;i<i1f;++i)
  1426.         {
  1427.             float value=fn(idx,g);
  1428.             value=a*w*value;
  1429.             idx+=di;
  1430.             buffer[2*i+0]+=value;
  1431.             buffer[2*i+1]+=value;
  1432.             w*=mw;
  1433.             g*=mg;
  1434.         }
  1435.  
  1436.         // Fade
  1437.         w=a*w;
  1438.  
  1439.         dw=-w/float(i2-i1f);
  1440.         for(ui32 i=i1f;i<i2;++i)
  1441.         {
  1442.             float value=fn(idx,g);
  1443.             value=w*value;
  1444.             idx+=di;
  1445.             buffer[2*i+0]+=value;
  1446.             buffer[2*i+1]+=value;
  1447.             w+=dw;
  1448.             g*=mg;
  1449.         }
  1450.     }
  1451.     else
  1452.     {
  1453.         g=1.0f;
  1454.         mg=1.0f;
  1455.  
  1456.         // Attack
  1457.         w=1.0f;
  1458.         mw=expf(-(C/A)*dt);
  1459.         for(ui32 i=i0;i<i0a;++i)
  1460.         {
  1461.             float value=fn(idx,g);
  1462.             value=a*(1.0f-w)*value;
  1463.             idx+=di;
  1464.             buffer[2*i+0]+=value;
  1465.             buffer[2*i+1]+=value;
  1466.             w*=mw;
  1467.         }
  1468.  
  1469.         // Decay/sustain
  1470.         a=a*(1.0f-w);
  1471.  
  1472.         if(R0>0.0f)
  1473.         {
  1474.             w=1.0f;
  1475.             mw=expf(-(C/R0)*dt);
  1476.             wd=1.0f;
  1477.             mwd=expf(-(C/D)*dt);
  1478.  
  1479.             if(S!=1.0f)
  1480.             {
  1481.                 for(ui32 i=i0a;i<i1;++i)
  1482.                 {
  1483.                     float value=fn(idx,g);
  1484.                     value=a*(S+cS*wd)*w*value;
  1485.                     idx+=di;
  1486.                     buffer[2*i+0]+=value;
  1487.                     buffer[2*i+1]+=value;
  1488.                     w*=mw;
  1489.                     wd*=mwd;
  1490.                 }
  1491.             }
  1492.             else
  1493.             {
  1494.                 for(ui32 i=i0a;i<i1;++i)
  1495.                 {
  1496.                     float value=fn(idx,g);
  1497.                     value=a*w*value;
  1498.                     idx+=di;
  1499.                     buffer[2*i+0]+=value;
  1500.                     buffer[2*i+1]+=value;
  1501.                     w*=mw;
  1502.                 }
  1503.             }
  1504.         }
  1505.         else
  1506.         {
  1507.             w=1.0f;
  1508.             mw=1.0f; // mw=expf(-(C/R0)*dt);
  1509.             wd=1.0f;
  1510.             mwd=expf(-(C/D)*dt);
  1511.  
  1512.             if(S!=1.0f)
  1513.             {
  1514.                 for(ui32 i=i0a;i<i1;++i)
  1515.                 {
  1516.                     float value=fn(idx,g);
  1517.                     value=a*(S+cS*wd)*value;
  1518.                     idx+=di;
  1519.                     buffer[2*i+0]+=value;
  1520.                     buffer[2*i+1]+=value;
  1521.                     wd*=mwd;
  1522.                 }
  1523.             }
  1524.             else
  1525.             {
  1526.                 for(ui32 i=i0a;i<i1;++i)
  1527.                 {
  1528.                     float value=fn(idx,g);
  1529.                     value=a*value;
  1530.                     idx+=di;
  1531.                     buffer[2*i+0]+=value;
  1532.                     buffer[2*i+1]+=value;
  1533.                 }
  1534.             }
  1535.         }
  1536.  
  1537.         // Release
  1538.         a=a*(S+cS*wd)*w;
  1539.         w=1.0f;
  1540.         mw=expf(-(C/R1)*dt);
  1541.         for(ui32 i=i1;i<i1f;++i)
  1542.         {
  1543.             float value=fn(idx,g);
  1544.             value=a*w*value;
  1545.             idx+=di;
  1546.             buffer[2*i+0]+=value;
  1547.             buffer[2*i+1]+=value;
  1548.             w*=mw;
  1549.         }
  1550.  
  1551.         // Fade
  1552.         w=a*w;
  1553.  
  1554.         dw=-w/float(i2-i1f);
  1555.         for(ui32 i=i1f;i<i2;++i)
  1556.         {
  1557.             float value=fn(idx,g);
  1558.             value=w*value;
  1559.             idx+=di;
  1560.             buffer[2*i+0]+=value;
  1561.             buffer[2*i+1]+=value;
  1562.             w+=dw;
  1563.         }
  1564.     }
  1565. }
  1566.  
  1567. //==============================================================================
  1568.  
  1569. template<typename Fn>
  1570. static void add_note_noise_lowpass(
  1571.     vector<float> &buffer,
  1572.     ui32 i0,
  1573.     ui32 i1,
  1574.     ui32 pitch,
  1575.     ui32 velocity_on,
  1576.     ui32 velocity_off,
  1577.     float f0,
  1578.     float f1,
  1579.     float A,
  1580.     float R,
  1581.     float a0,
  1582.     Fn fn)
  1583. {
  1584.     (void)velocity_off;
  1585.  
  1586.     const float C=2.5f;
  1587.     float dt=1.0f/float(freq);
  1588.     float g=2.0f*pi*f0*dt;
  1589.     float mg=expf(logf(f1/f0)*(dt/R));
  1590.     float w0=a0*sqrtf(float(freq)/f0)*get_note_volume(pitch,velocity_on),mw0=expf(-(C/R)*dt)/sqrtf(mg);
  1591.     float w1=1.0,mw1=expf(-(C/A)*dt);
  1592.     ui32 rng=1;
  1593.  
  1594.     ui32 snd_len=buffer.size()/2;
  1595.  
  1596.     if(i1>snd_len) i1=snd_len;
  1597.  
  1598.     float y=0.0f;
  1599.  
  1600.     for(ui32 i=i0;i<i1;++i)
  1601.     {
  1602.         rng=1103515245*rng+12345;
  1603.         float x=4.65661287e-10f*float(rng)-1.0f;
  1604.         y=y*(1.0f-g)+x*g;
  1605.         float value=w0*(1.0f-w1)*fn(y);
  1606.         buffer[2*i+0]+=value;
  1607.         buffer[2*i+1]+=value;
  1608.         w0*=mw0;
  1609.         w1*=mw1;
  1610.         g*=mg;
  1611.     }
  1612. }
  1613.  
  1614. static void add_note_percussion(
  1615.     vector<float> &buffer,
  1616.     ui32 i0,
  1617.     ui32 i1,
  1618.     ui32 pitch,
  1619.     ui32 velocity_on,
  1620.     ui32 velocity_off)
  1621. {
  1622.     (void)i1;
  1623.     (void)pitch;
  1624.  
  1625.     add_note_noise_lowpass(
  1626.         buffer,
  1627.         i0,i0+2*freq,
  1628.         64,
  1629.         velocity_on,
  1630.         velocity_off,
  1631.         7300.0f,
  1632.         1700.0f,
  1633.         1.0f/512.0f,
  1634.         0.5f,
  1635.         0.17f,
  1636.         [](float x)->float
  1637.         {
  1638.            return x;
  1639.         });
  1640. }
  1641.  
  1642. //==============================================================================
  1643.  
  1644. static void add_note(vector<float> &buffer,const NoteInfo &note)
  1645. {
  1646.     ui32 i0=ui32(ui64(note.start)*freq/time_units_per_second);
  1647.     ui32 i1=ui32(ui64(note.start+note.duration)*freq/time_units_per_second);
  1648.     if(note.channel==9)
  1649.     {
  1650.         add_note_percussion(buffer,i0,i1,note.pitch,note.velocity_on,note.velocity_off);
  1651.     }
  1652.     else
  1653.     {
  1654.         ui32 preset=note.preset;
  1655.         preset=instrument_map[preset];
  1656.         switch(preset)
  1657.         {
  1658.             case 0: // Acoustic Grand Piano
  1659.             case 1: // Bright Acoustic Piano
  1660.             case 2: // Electric Grand Piano
  1661.             case 3: // Honky-tonk Piano
  1662.             {
  1663.                 if(i1-i0>5*freq) i1=i0+5*freq;
  1664.                 add_note_adsr_index(
  1665.                     buffer,
  1666.                     i0,i1,
  1667.                     note.pitch,note.velocity_on,note.velocity_off,
  1668.                     1.0f/512.0f,1.0f/128.0f,0.625f,3.5f,0.5f,
  1669.                     1.0f,1.0f,1.0f,
  1670.                     [](ui32 idx,float g)->float
  1671.                     {
  1672.                         float f=1.0f-g;
  1673.                         return
  1674.                             g*snd_table_piano0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)]+
  1675.                             f*snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1676.                     });
  1677.                 break;
  1678.             }
  1679.             case 4: // Electric Piano 1
  1680.             {
  1681.                 if(i1-i0>7*freq) i1=i0+7*freq;
  1682.                 add_note_adsr_index(
  1683.                     buffer,
  1684.                     i0,i1,
  1685.                     note.pitch,note.velocity_on,note.velocity_off,
  1686.                     1.0f/256.0f,1.0f/32.0f,0.875f,3.5f,0.5f,
  1687.                     1.0f,0.5f,1.0f,
  1688.                     [](ui32 idx,float g)->float
  1689.                     {
  1690.                         (void)g;
  1691.                         return
  1692.                             snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1693.                     });
  1694.                 add_note_adsr_index(
  1695.                     buffer,
  1696.                     i0,i1,
  1697.                     note.pitch,note.velocity_on,note.velocity_off,
  1698.                     1.0f/256.0f,1.0f/32.0f,0.875f,3.5f,0.5f,
  1699.                     1.0f,0.5f,1.007f,
  1700.                     [](ui32 idx,float g)->float
  1701.                     {
  1702.                         (void)g;
  1703.                         return
  1704.                             snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1705.                     });
  1706.                 break;
  1707.             }
  1708.             case 5: // Electric Piano 2
  1709.             case 6: // Harpsichord
  1710.             case 7: // Clavinet
  1711.             {
  1712.                 if(i1-i0>5*freq) i1=i0+5*freq;
  1713.                 add_note_adsr_index(
  1714.                     buffer,
  1715.                     i0,i1,
  1716.                     note.pitch,note.velocity_on,note.velocity_off,
  1717.                     1.0f/512.0f,1.0f/128.0f,0.625f,3.5f,0.5f,
  1718.                     1.0f,1.0f,1.0f,
  1719.                     [](ui32 idx,float g)->float
  1720.                     {
  1721.                         float f=1.0f-g;
  1722.                         return
  1723.                             g*snd_table_piano0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)]+
  1724.                             f*snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1725.                     });
  1726.                 break;
  1727.             }
  1728.             case 8: // Celesta
  1729.             {
  1730.                 float dB=powf(10.0f,0.05f); // Amplitude, not power.
  1731.  
  1732.                 float harmonics[][3]=
  1733.                 {
  1734.                     {1.0f,0.0f,1.25f},
  1735.                     {3.0f,-7.0f,0.65f},
  1736.                     {4.0f,-40.0f,0.75f},
  1737.                     {5.5f,-20.0f,0.4f},
  1738.                     {6.5f,-31.0f,0.35f},
  1739.                     {9.0f,-35.0f,0.17f},
  1740.                     {10.0f,-53.0f,0.25f},
  1741.                     {15.0f,-75.0f,0.125f},
  1742.                     {16.0f,-50.0f,0.125f}
  1743.                 };
  1744.                 for(ui32 i=0;i<sizeof(harmonics)/sizeof(harmonics[0]);++i)
  1745.                 {
  1746.                     add_note_adsr_index(
  1747.                         buffer,
  1748.                         i0,i0,
  1749.                         note.pitch,note.velocity_on,note.velocity_off,
  1750.                         0.0075f,0.0f,1.0f,0.0f,harmonics[i][2],
  1751.                         0.0f,0.875f*powf(dB,harmonics[i][1]),harmonics[i][0],
  1752.                         [](ui32 idx,float g)->float
  1753.                         {
  1754.                             (void)g;
  1755.                             return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1756.                         });
  1757.                 }
  1758.                 break;
  1759.             }
  1760.             case 9: // Glockenspiel
  1761.             {
  1762.                 add_note_adsr_index(
  1763.                     buffer,
  1764.                     i0,i0,
  1765.                     note.pitch,note.velocity_on,note.velocity_off,
  1766.                     0.0025f,0.0f,1.0f,0.0f,4.5f,
  1767.                     0.0f,0.25f,1.0f,
  1768.                     [](ui32 idx,float g)->float
  1769.                     {
  1770.                         (void)g;
  1771.                         return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1772.                     });
  1773.                 add_note_adsr_index(
  1774.                     buffer,
  1775.                     i0,i0,
  1776.                     note.pitch,note.velocity_on,note.velocity_off,
  1777.                     0.0025f,0.0f,1.0f,0.0f,1.7f,
  1778.                     0.0f,0.25f,1.0f,
  1779.                     [](ui32 idx,float g)->float
  1780.                     {
  1781.                         (void)g;
  1782.                         return snd_table_glockenspiel0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1783.                     });
  1784.                 add_note_adsr_index(
  1785.                     buffer,
  1786.                     i0,i0,
  1787.                     note.pitch,note.velocity_on,note.velocity_off,
  1788.                     0.0025f,0.0f,1.0f,0.0f,0.7f,
  1789.                     0.0f,0.25f,1.0f,
  1790.                     [](ui32 idx,float g)->float
  1791.                     {
  1792.                         (void)g;
  1793.                         return snd_table_glockenspiel1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1794.                     });
  1795.                 add_note_adsr_index(
  1796.                     buffer,
  1797.                     i0,i0,
  1798.                     note.pitch,note.velocity_on,note.velocity_off,
  1799.                     0.0025f,0.0f,1.0f,0.0f,0.2f,
  1800.                     0.0f,0.25f*0.125f,31.0f,
  1801.                     [](ui32 idx,float g)->float
  1802.                     {
  1803.                         (void)g;
  1804.                         return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1805.                     });
  1806.                 break;
  1807.             }
  1808.             case 10: // Music Box
  1809.             {
  1810.                 float dB=powf(10.0f,0.05f); // Amplitude, not power.
  1811.  
  1812.                 float harmonics[][3]=
  1813.                 {
  1814.                     {1.0f,0.0f,2.5f},
  1815.                     {10.0f,-20.0f,1.0f},
  1816.                     {12.0f,-34.2f,1.0f},
  1817.                     {19.0f,-34.1f,0.7f},
  1818.                     {28.0f,-46.5f,0.25f}
  1819.                 };
  1820.                 for(ui32 i=0;i<sizeof(harmonics)/sizeof(harmonics[0]);++i)
  1821.                 {
  1822.                     bool flag=(i==1||i==2);
  1823.                     add_note_adsr_index(
  1824.                         buffer,
  1825.                         i0,i0,
  1826.                         note.pitch,note.velocity_on,note.velocity_off,
  1827.                         0.005f,0.5f,0.25f,0.0f,harmonics[i][2],
  1828.                         0.0f,0.875f*(0.5f+0.5f*float(!flag))*powf(dB,harmonics[i][1]),harmonics[i][0],
  1829.                         [](ui32 idx,float g)->float
  1830.                         {
  1831.                             (void)g;
  1832.                             return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1833.                         });
  1834.                     if(flag)
  1835.                         add_note_adsr_index(
  1836.                             buffer,
  1837.                             i0,i0,
  1838.                             note.pitch,note.velocity_on,note.velocity_off,
  1839.                             0.005f,0.5f,0.25f,0.0f,harmonics[i][2],
  1840.                             0.0f,0.875f*0.5f*powf(dB,harmonics[i][1]),harmonics[i][0]*(1.0f+17.0f/get_note_freq(note.pitch,note.velocity_on)),
  1841.                             [](ui32 idx,float g)->float
  1842.                             {
  1843.                                 (void)g;
  1844.                                 return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1845.                             });
  1846.                 }
  1847.                 break;
  1848.             }
  1849.             case 11: // Vibraphone
  1850.             {
  1851.                 add_note_adsr_index(
  1852.                     buffer,
  1853.                     i0,i1,
  1854.                     note.pitch,note.velocity_on,note.velocity_off,
  1855.                     1.0f/128.0f,0.0f,1.0f,0.0f,0.5f,
  1856.                     0.0f,0.5f,1.0f,
  1857.                     [](ui32 idx,float g)->float
  1858.                     {
  1859.                         (void)g;
  1860.                         return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1861.                     });
  1862.                 add_note_adsr_index(
  1863.                     buffer,
  1864.                     i0,i1,
  1865.                     note.pitch,note.velocity_on,note.velocity_off,
  1866.                     1.0f/128.0f,0.0f,1.0f,0.0f,0.5f,
  1867.                     0.0f,0.5f,1.0f+1.73f/get_note_freq(note.pitch,note.velocity_on),
  1868.                     [](ui32 idx,float g)->float
  1869.                     {
  1870.                         (void)g;
  1871.                         return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1872.                     });
  1873.                 break;
  1874.             }
  1875.             case 12: // Marimba
  1876.             {
  1877.                 add_note_adsr_index(
  1878.                     buffer,
  1879.                     i0,i0,
  1880.                     note.pitch,note.velocity_on,note.velocity_off,
  1881.                     0.05f,0.0f,1.0f,0.0f,1.0f,
  1882.                     0.0f,1.0f,1.0f,
  1883.                     [](ui32 idx,float g)->float
  1884.                     {
  1885.                         (void)g;
  1886.                         return
  1887.                             snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1888.                     });
  1889.                 break;
  1890.             }
  1891.             case 13: // Xylophone
  1892.             {
  1893.                 float dB=powf(10.0f,0.05f); // Amplitude, not power.
  1894.                 float f[]={1.00f,2.74f,4.58f,6.68f,10.61f,13.89f,15.90f,21.81f};
  1895.                 float b=1.0f/powf(dB,-35.0f);
  1896.                 b*=powf(2.0f,0.5f-float(note.pitch)/80.0f);
  1897.                 float a[sizeof(f)/sizeof(f[0])]={
  1898.                     b*powf(dB,-47.6f),
  1899.                     b*powf(dB,-61.7f),
  1900.                     b*powf(dB,-61.7f),
  1901.                     b*powf(dB,-39.8f),
  1902.                     b*powf(dB,-51.6f),
  1903.                     b*powf(dB,-48.9f),
  1904.                     b*powf(dB,-54.1f),
  1905.                     b*powf(dB,-64.0f)
  1906.                 };
  1907.  
  1908.                 for(ui32 k=0;k<sizeof(f)/sizeof(f[0]);++k)
  1909.                     add_note_adsr_index(
  1910.                         buffer,
  1911.                         i0,i0,
  1912.                         note.pitch,note.velocity_on,note.velocity_off,
  1913.                         0.005f,0.0f,1.0f,0.0f,0.2f*powf(2.0f,-0.375f*float(k)),
  1914.                         0.0f,a[k],f[k],
  1915.                         [](ui32 idx,float g)->float
  1916.                         {
  1917.                             (void)g;
  1918.                             return
  1919.                                 snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1920.                         });
  1921.  
  1922.                 add_note_adsr_index(
  1923.                     buffer,
  1924.                     i0,i0,
  1925.                     note.pitch,note.velocity_on,note.velocity_off,
  1926.                     0.0025f,0.0f,1.0f,0.0f,0.375f,
  1927.                     0.0f,powf(2.0f,-2.5f+float(note.pitch)/128.0f),1.0f,
  1928.                     [](ui32 idx,float g)->float
  1929.                     {
  1930.                         (void)g;
  1931.                         return
  1932.                             snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1933.                     });
  1934.                 break;
  1935.             }
  1936.             case 14: // Tubular Bells
  1937.             {
  1938.                 for(ui32 i=0;i<5;++i)
  1939.                 {
  1940.                     add_note_adsr_index(
  1941.                         buffer,
  1942.                         i0,i0,
  1943.                         note.pitch,note.velocity_on,note.velocity_off,
  1944.                         0.0025f,0.0f,1.0f,0.0f,3.5f/(1.0f+2.0f*float(i)),
  1945.                         0.0f,powf(2.0f,-0.25f-0.5f*float(i)),1.0f+2.0f*float(i),
  1946.                         [](ui32 idx,float g)->float
  1947.                         {
  1948.                             (void)g;
  1949.                             return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1950.                         });
  1951.                 }
  1952.                 break;
  1953.             }
  1954.             case 15: //Dulcimer
  1955.             {
  1956.                 add_note_adsr_index(
  1957.                     buffer,
  1958.                     i0,i0,
  1959.                     note.pitch,note.velocity_on,note.velocity_off,
  1960.                     1.0f/128.0f,1.0f/8.0f,0.5f,0.0f,2.5f,
  1961.                     0.05f,1.0f,1.0f,
  1962.                     [](ui32 idx,float g)->float
  1963.                     {
  1964.                         float f=1.0f-g;
  1965.                         float x=snd_table_dulcimer0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1966.                         float y=snd_table_dulcimer1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1967.                         return g*x+f*y;
  1968.                     });
  1969.                 break;
  1970.             }
  1971.             case 16: // Drawbar Organ
  1972.             case 17: // Percussive Organ
  1973.             case 18: // Rock Organ
  1974.             case 19: // Church Organ
  1975.             case 20: // Reed Organ
  1976.             case 21: // Accordion
  1977.             case 22: // Harmonica
  1978.             case 23: // Tango Accordion
  1979.             {
  1980.                 add_note_adsr_index(
  1981.                     buffer,
  1982.                     i0,i1,
  1983.                     note.pitch,note.velocity_on,note.velocity_off,
  1984.                     0.125f,0.0f,1.0f,0.0f,1.0f,
  1985.                     0.0f,0.37f,1.0f,
  1986.                     [](ui32 idx,float g)->float
  1987.                     {
  1988.                         (void)g;
  1989.                         return snd_table_organ[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  1990.                     });
  1991.                 add_note_adsr_index(
  1992.                     buffer,
  1993.                     i0,i1,
  1994.                     note.pitch,note.velocity_on,note.velocity_off,
  1995.                     0.125f,0.0f,1.0f,0.0f,1.0f,
  1996.                     0.0f,0.32f,1.0f+7.3f/get_note_freq(note.pitch,note.velocity_on),
  1997.                     [](ui32 idx,float g)->float
  1998.                     {
  1999.                         (void)g;
  2000.                         return snd_table_organ[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2001.                     });
  2002.                 add_note_adsr_index(
  2003.                     buffer,
  2004.                     i0,i1,
  2005.                     note.pitch,note.velocity_on,note.velocity_off,
  2006.                     0.125f,0.0f,1.0f,0.0f,1.0f,
  2007.                     0.0f,0.31f,1.0f+17.0f/get_note_freq(note.pitch,note.velocity_on),
  2008.                     [](ui32 idx,float g)->float
  2009.                     {
  2010.                         (void)g;
  2011.                         return snd_table_organ[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2012.                     });
  2013.                 break;
  2014.             }
  2015.             case 24: // Acoustic Guitar (nylon)
  2016.             case 25: // Acoustic Guitar (steel)
  2017.             case 26: // Electric Guitar (jazz)
  2018.             case 27: // Electric Guitar (clean)
  2019.             case 28: // Electric Guitar (muted)
  2020.             case 29: // Overdriven Guitar
  2021.             case 30: // Distortion Guitar
  2022.             case 31: // Guitar Harmonics
  2023.             {
  2024.                 for(ui32 k=1;k<15;++k)
  2025.                 {
  2026.                     add_note_adsr_index(
  2027.                         buffer,
  2028.                         i0,i0,
  2029.                         note.pitch,note.velocity_on,note.velocity_off,
  2030.                         0.025f/float(5+k),0.0f,1.0f,0.0f,3.5f/(1.0f+0.73f*float(k)),
  2031.                         0.0f,0.5f*sinf(3.7f*float(k))/float(k),float(k),
  2032.                         [](ui32 idx,float g)->float
  2033.                         {
  2034.                             (void)g;
  2035.                             float x=snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2036.                             return x;
  2037.                         });
  2038.                 }
  2039.                 break;
  2040.             }
  2041.             case 40: // Violin
  2042.             case 41: // Viola
  2043.             case 42: // Cello
  2044.             case 43: // Contrabass
  2045.             case 44: // Tremolo Strings
  2046.             {
  2047.                 add_note_adsr_index(
  2048.                     buffer,
  2049.                     i0,i1,
  2050.                     note.pitch,note.velocity_on,note.velocity_off,
  2051.                     1.0f/16.0f,0.0f,1.0f,0.0f,0.5f,
  2052.                     0.25f,1.0f,1.0f,
  2053.                     [](ui32 idx,float g)->float
  2054.                     {
  2055.                         float f=1.0f-g;
  2056.                         float x=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2057.                         float y=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2058.                         return f*x+g*y;
  2059.                     });
  2060.                 add_note_adsr_index(
  2061.                     buffer,
  2062.                     i0,i1,
  2063.                     note.pitch,note.velocity_on,note.velocity_off,
  2064.                     0.5f,0.0f,1.0f,0.0f,1.0f/16.0f,
  2065.                     0.0f,0.75f,1.0f+2.5f/get_note_freq(note.pitch,note.velocity_on),
  2066.                     [](ui32 idx,float g)->float
  2067.                     {
  2068.                         (void)g;
  2069.                         float x=snd_table_violin1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2070.                         return x;
  2071.                     });
  2072.                 break;
  2073.             }
  2074.             case 45: // Pizzicato Strings
  2075.             {
  2076.                 add_note_adsr_index(
  2077.                     buffer,
  2078.                     i0,i0,
  2079.                     note.pitch,note.velocity_on,note.velocity_off,
  2080.                     1.0f/128.0f,0.0f,1.0f,0.0f,1.0f,
  2081.                     1.0f/32.0f,1.0f,1.0f,
  2082.                     [](ui32 idx,float g)->float
  2083.                     {
  2084.                         float f=1.0f-g;
  2085.                         float x=snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2086.                         float y=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2087.                         y=y*(1.5f-0.5f*y*y);
  2088.                         y=y*(1.5f-0.5f*y*y);
  2089.                         x=x-0.125f*x*x*x;
  2090.                         return f*x+g*y;
  2091.                     });
  2092.                 break;
  2093.             }
  2094.             case 46: // Orchestral Harp
  2095.             {
  2096.                 add_note_adsr_index(
  2097.                     buffer,
  2098.                     i0,i0,
  2099.                     note.pitch,note.velocity_on,note.velocity_off,
  2100.                     0.0025f,1.0f/128.0f,0.875f,0.0f,2.5f,
  2101.                     0.1875f,1.0f,1.0f,
  2102.                     [](ui32 idx,float g)->float
  2103.                     {
  2104.                         float f=1.0f-g;
  2105.                         float x=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2106.                         x=x*(0.5f*f+g*(0.5f+g*x*x));
  2107.                         return x;
  2108.                     });
  2109.                 break;
  2110.             }
  2111.             case 47: // Timpani
  2112.             {
  2113.                 for(ui32 k=1;k<=5;++k)
  2114.                 {
  2115.                     add_note_noise_lowpass(
  2116.                         buffer,
  2117.                         i0,i0+2*freq,
  2118.                         note.pitch,
  2119.                         note.velocity_on,
  2120.                         note.velocity_off,
  2121.                         0.5f*powf(2.5f,0.5f*float(k))*get_note_freq(note.pitch,note.velocity_on),
  2122.                         0.25f*get_note_freq(note.pitch,note.velocity_on),
  2123.                         1.0f/128.0f,
  2124.                         2.5f/float(k+(k>0)),
  2125.                         0.37f/powf(2.0f,0.5f*float(k)),
  2126.                         [](float x)->float
  2127.                         {
  2128.                             return 1.5f*x-0.5f*x*x*x;
  2129.                         });
  2130.                 }
  2131.                 break;
  2132.             }
  2133.  
  2134.             case 48: // String Ensemble 1
  2135.             case 49: // String Ensemble 2
  2136.             {
  2137.                 add_note_adsr_index(
  2138.                     buffer,
  2139.                     i0,i1,
  2140.                     note.pitch,note.velocity_on,note.velocity_off,
  2141.                     1.0f/16.0f,0.0f,1.0f,0.0f,0.5f,
  2142.                     0.25f,0.5f,1.0f,
  2143.                     [](ui32 idx,float g)->float
  2144.                     {
  2145.                         float f=1.0f-g;
  2146.                         float x=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2147.                         float y=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2148.                         return f*x+g*y;
  2149.                     });
  2150.                 add_note_adsr_index(
  2151.                     buffer,
  2152.                     i0,i1,
  2153.                     note.pitch,note.velocity_on,note.velocity_off,
  2154.                     1.0f/16.0f,0.0f,1.0f,0.0f,0.5f,
  2155.                     0.25f,0.25f,1.0f+1.25f/get_note_freq(note.pitch,note.velocity_on),
  2156.                     [](ui32 idx,float g)->float
  2157.                     {
  2158.                         float f=1.0f-g;
  2159.                         float x=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2160.                         float y=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2161.                         return f*x+g*y;
  2162.                     });
  2163.                 add_note_adsr_index(
  2164.                     buffer,
  2165.                     i0,i1,
  2166.                     note.pitch,note.velocity_on,note.velocity_off,
  2167.                     1.0f/16.0f,0.0f,1.0f,0.0f,0.5f,
  2168.                     0.25f,0.125f,1.0f+3.7f/get_note_freq(note.pitch,note.velocity_on),
  2169.                     [](ui32 idx,float g)->float
  2170.                     {
  2171.                         float f=1.0f-g;
  2172.                         float x=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2173.                         float y=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2174.                         return f*x+g*y;
  2175.                     });
  2176.                 break;
  2177.             }
  2178.             case 50: // Synth Strings 1
  2179.             case 51: // Synth Strings 2
  2180.             {
  2181.                 add_note_adsr_index(
  2182.                     buffer,
  2183.                     i0,i1,
  2184.                     note.pitch,note.velocity_on,note.velocity_off,
  2185.                     1.0f/16.0f,0.0f,1.0f,0.0f,0.5f,
  2186.                     0.25f,1.0f,1.0f,
  2187.                     [](ui32 idx,float g)->float
  2188.                     {
  2189.                         float f=1.0f-g;
  2190.                         float x=snd_table_violin0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2191.                         float y=snd_table_piano1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2192.                         return f*x+g*y;
  2193.                     });
  2194.             }
  2195.             case 56: // Trumpet
  2196.             {
  2197.                 add_note_adsr_index(
  2198.                     buffer,
  2199.                     i0,i1,
  2200.                     note.pitch,note.velocity_on,note.velocity_off,
  2201.                     1.0f/32.0f,0.25f,5.0f/8.0f,0.0f,0.5f,
  2202.                     0.0f,1.0f,(1.0f/3.0f),
  2203.                     [](ui32 idx,float g)->float
  2204.                     {
  2205.                         (void)g;
  2206.                         float x=snd_table_trumpet[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2207.                         return x;
  2208.                     });
  2209.                 add_note_adsr_index(
  2210.                     buffer,
  2211.                     i0,i1,
  2212.                     note.pitch,note.velocity_on,note.velocity_off,
  2213.                     0.125f,0.25f,7.0f/8.0f,0.0f,0.5f,
  2214.                     0.0f,0.25f,(1.0f/3.0f)+3.7f/get_note_freq(note.pitch,note.velocity_on),
  2215.                     [](ui32 idx,float g)->float
  2216.                     {
  2217.                         (void)g;
  2218.                         float x=snd_table_trumpet[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2219.                         return x;
  2220.                     });
  2221.                 break;
  2222.             }
  2223.             case 57:
  2224.             case 58:
  2225.             case 59:
  2226.             case 60:
  2227.             case 61:
  2228.             case 62:
  2229.             case 63:
  2230.             case 64:
  2231.             case 65:
  2232.             case 66:
  2233.             case 67:
  2234.             case 68:
  2235.             case 69:
  2236.             case 70:
  2237.             case 71:
  2238.             {
  2239.                 if(i1>i0+5*freq) i1=i0+5*freq;
  2240.                 add_note_adsr_index(
  2241.                     buffer,
  2242.                     i0,i1,
  2243.                     note.pitch,note.velocity_on,note.velocity_off,
  2244.                     1.0f,0.0f,1.0f,0.0f,1.0f,
  2245.                     2.0f,1.0f,1.0f,
  2246.                     [](ui32 idx,float g)->float
  2247.                     {
  2248.                         float x=snd_table_brass[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2249.                         float y=snd_table_brass[(idx+500000000)>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2250.                         float f=1.0f-g;
  2251.                         return
  2252.                             f*x*x-0.25f*y;
  2253.                     });
  2254.                 break;
  2255.             }
  2256.             case 74: // Recorder
  2257.             case 75: // Pan Flute
  2258.             case 76: // Blown bottle
  2259.             case 77: // Shakuhachi
  2260.             case 78: // Whistle
  2261.             case 79: // Ocarina
  2262.             {
  2263.                 add_note_adsr_index(
  2264.                     buffer,
  2265.                     i0,i1,
  2266.                     note.pitch,note.velocity_on,note.velocity_off,
  2267.                     0.025f,0.0f,1.0f,0.0f,0.125f,
  2268.                     0.25f,1.25f,1.0f,
  2269.                     [](ui32 idx,float g)->float
  2270.                     {
  2271.                         float f=1.0f-g;
  2272.                         float x=
  2273.                             g*snd_table_ocarina0[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)]+
  2274.                             f*snd_table_ocarina1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2275.                         return x;
  2276.                     });
  2277.                 add_note_adsr_index(
  2278.                     buffer,
  2279.                     i0,i1,
  2280.                     note.pitch,note.velocity_on,note.velocity_off,
  2281.                     0.025f,0.0f,1.0f,0.0f,0.125f,
  2282.                     0.0f,0.25f,1.0f+7.0f/get_note_freq(note.pitch,note.velocity_on),
  2283.                     [](ui32 idx,float g)->float
  2284.                     {
  2285.                         (void)g;
  2286.                         float x=
  2287.                             snd_table_ocarina1[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2288.                         return x;
  2289.                     });
  2290.                 add_note_adsr_index(
  2291.                     buffer,
  2292.                     i1,i1,
  2293.                     note.pitch,note.velocity_on,note.velocity_off,
  2294.                     0.25f,0.0f,1.0f,0.0f,1.0f,
  2295.                     0.0f,0.25f,1.0f,
  2296.                     [](ui32 idx,float g)->float
  2297.                     {
  2298.                         (void)g;
  2299.                         float x=
  2300.                             snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2301.                         return x;
  2302.                     });
  2303.                 break;
  2304.             }
  2305.             case 80: // Lead 1 (square)
  2306.             {
  2307.                 add_note_adsr_index(
  2308.                     buffer,
  2309.                     i0,i1,
  2310.                     note.pitch,note.velocity_on,note.velocity_off,
  2311.                     0.125f,0.0f,1.0f,0.0f,0.5f,
  2312.                     0.0f,1.0f,1.0f,
  2313.                     [](ui32 idx,float g)->float
  2314.                     {
  2315.                         (void)g;
  2316.                         float x=float(idx>>31)*2.0f-1.0f;
  2317.                         return x;
  2318.                     });
  2319.                 break;
  2320.             }
  2321.             case 81: // Lead 2 (sawtooth)
  2322.             {
  2323.                 add_note_adsr_index(
  2324.                     buffer,
  2325.                     i0,i1,
  2326.                     note.pitch,note.velocity_on,note.velocity_off,
  2327.                     0.125f,0.0f,1.0f,0.0f,0.5f,
  2328.                     0.0f,1.0f,1.0f,
  2329.                     [](ui32 idx,float g)->float
  2330.                     {
  2331.                         (void)g;
  2332.                         float x=float(idx)*4.65661287e-10f-1.0f;
  2333.                         return x;
  2334.                     });
  2335.                 break;
  2336.             }
  2337.             case 86: // Lead 7 (fifths)
  2338.             {
  2339.                 add_note_adsr_index(
  2340.                     buffer,
  2341.                     i0,i1,
  2342.                     note.pitch,note.velocity_on,note.velocity_off,
  2343.                     0.125f,0.0f,1.0f,0.0f,0.5f,
  2344.                     0.0f,1.0f,1.0f,
  2345.                     [](ui32 idx,float g)->float
  2346.                     {
  2347.                         (void)g;
  2348.                         float x=
  2349.                             0.5f*snd_table_cosine[(2*idx)>>(32-LOG2_WAVEFORM_TABLE_SIZE)]+
  2350.                             0.5f*snd_table_cosine[(3*idx)>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2351.                         return x;
  2352.                     });
  2353.                 break;
  2354.             }
  2355.             default:
  2356.             {
  2357.                 if(i1-i0>5*freq) i1=i0+5*freq;
  2358.                 add_note_adsr_index(
  2359.                     buffer,
  2360.                     i0,i1,
  2361.                     note.pitch,note.velocity_on,note.velocity_off,
  2362.                     0.0125f,0.0f,1.0f,1.0f,2.5f,
  2363.                     0.0f,1.0f,1.0f,
  2364.                     [](ui32 idx,float g)->float
  2365.                     {
  2366.                         (void)g;
  2367.                         return snd_table_cosine[idx>>(32-LOG2_WAVEFORM_TABLE_SIZE)];
  2368.                     });
  2369.             }
  2370.         }
  2371.     }
  2372. }
  2373.  
  2374. //==============================================================================
  2375.  
  2376. static bool notes_start_less(
  2377.     const NoteInfo &l,
  2378.     const NoteInfo &r)
  2379. {
  2380.     return l.start<r.start;
  2381. }
  2382.  
  2383. static vector<float> generate_pcm(const vector<NoteInfo> &notes)
  2384. {
  2385.     vector<float> ret((get_duration(notes)+5)*freq*2,0.0f);
  2386.     vector<NoteInfo> notes_copy=notes;
  2387.     std::sort(notes_copy.begin(),notes_copy.end(),notes_start_less);
  2388.     for(ui32 i=0,n=notes.size();i<n;++i)
  2389.     {
  2390.         printf("\r  Adding notes: %d/%d...",i,n);
  2391.         add_note(ret,notes[i]);
  2392.     }
  2393.     printf("\r  Adding notes: %d/%d... done!\n",notes.size(),notes.size());
  2394.     return ret;
  2395. }
  2396.  
  2397. //==============================================================================
  2398.  
  2399. int main(int argc,char **argv)
  2400. {
  2401.     if(argc<2)
  2402.     {
  2403.         printf("Usage:\n");
  2404.         printf("synth1 [options] file\n");
  2405.         printf("Options:\n");
  2406.         printf("  -dump                    Dumps note information and exits\n");
  2407.         printf("  -o file                  Output filename\n");
  2408.         printf("  -volume=N                Set global volume (default: 0.125)\n");
  2409.         printf("  -remapMtoN               Remap preset (instrument) M (1-based) to preset N\n");
  2410.  
  2411.         return 0;
  2412.     }
  2413.  
  2414.     for(int i=0;i<128;++i)
  2415.         instrument_map[i]=ui8(i);
  2416.  
  2417.     strcpy(input_filename,argv[argc-1]);
  2418.     strcpy(output_filename,input_filename);
  2419.     strcpy(output_filename+strlen(output_filename),".wav");
  2420.  
  2421.     for(int i=1;i+1<argc;++i)
  2422.     {
  2423.         if(strncmp(argv[i],"-dump",5)==0)
  2424.         {
  2425.             dump_note_info=true;
  2426.         }
  2427.         if(strncmp(argv[i],"-o",2)==0)
  2428.         {
  2429.             strcpy(output_filename,argv[i+1]);
  2430.             ++i;
  2431.         }
  2432.         if(strncmp(argv[i],"-volume=",8)==0)
  2433.         {
  2434.             sscanf(argv[i],"-volume=%g",&global_volume);
  2435.         }
  2436.         if(strncmp(argv[i],"-remap",6)==0)
  2437.         {
  2438.             int x,y;
  2439.             sscanf(argv[i],"-remap%dto%d",&x,&y);
  2440.             x-=1;
  2441.             y-=1;
  2442.             if(x>=0&&x<0x80&&y>=0&&y<0x80)
  2443.             {
  2444.                 printf("Remapped %d ( %s ) to %d ( %s ).\n",
  2445.                     x+1,
  2446.                     instrument_names[x],
  2447.                     y+1,
  2448.                     instrument_names[y]);
  2449.                 instrument_map[x]=ui8(y);
  2450.             }
  2451.         }
  2452.     }
  2453.  
  2454.     printf("Opening file: \"%s\"...",input_filename);
  2455.     input_file=read_file(input_filename);
  2456.     if(input_file.size()>0)
  2457.         printf(" done (%d bytes)!\n",input_file.size());
  2458.     else
  2459.     {
  2460.         printf("ERROR (%d bytes)!\n",input_file.size());
  2461.         return 1;
  2462.     }
  2463.     printf("Parsing input...");
  2464.  
  2465.     ByteStreamView view;
  2466.     view.buf=&input_file;
  2467.     view.pos=0;
  2468.  
  2469.     MIDI midi=read_midi(view);
  2470.  
  2471.     printf(" done!\n");
  2472.     printf("MIDI information:\n");
  2473.     print_midi_info(midi);
  2474.  
  2475.     printf("Extracting note information... ");
  2476.  
  2477.     vector<NoteInfo> notes=exract_notes(midi);
  2478.  
  2479.     printf(" done!\n");
  2480.     printf("%d notes extracted.\n",notes.size());
  2481.  
  2482.     ui32 duration=get_duration(notes);
  2483.  
  2484.     printf("Duration: %d s [%d:%02d]\n",
  2485.         duration,
  2486.         duration/60,
  2487.         duration%60);
  2488.  
  2489.     bool instruments[128+1+47];
  2490.     get_instrument_list(notes,instruments);
  2491.  
  2492.     printf("Instruments:\n");
  2493.     for(ui32 i=0;i<128+1+47;++i)
  2494.         if(instruments[i])
  2495.             printf("%s  [%3d] %s\n",
  2496.                 (i>=128+1?"  ":""),
  2497.                 (i>=128+1?i-129+35:(i==128?0:i+1)),
  2498.                 instrument_names[i]);
  2499.  
  2500.     if(dump_note_info)
  2501.     {
  2502.         dump_notes(notes);
  2503.         return 0;
  2504.     }
  2505.  
  2506.     printf("Initializing the tables...");
  2507.     init_tables();
  2508.     printf(" done!\n");
  2509.  
  2510.     printf("Generating PCM sound data.\n");
  2511.     int t=clock();
  2512.     vector<float> sound=generate_pcm(notes);
  2513.  
  2514.     t=clock()-t;
  2515.     printf("Generation time: %.2f s.\n",double(t)/double(CLOCKS_PER_SEC));
  2516.  
  2517.     printf("Writing file: \"%s\"...",output_filename);
  2518.     if(write_file(output_filename,sound))
  2519.         printf(" done!\n");
  2520.     else
  2521.     {
  2522.         printf("ERROR!\n");
  2523.         return 1;
  2524.     }
  2525.  
  2526.     return 0;
  2527. }