v 0. Pasted by Anonymous as cpp at 2016-09-12 19:10:18 MSK and set expiration to never.

Paste will expire never.

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