//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Sun Oct 24 10:39:47 PDT 1999
// Last Modified: Fri Nov 10 10:10:03 PST 2000
// Last Modified: Sat Nov 25 20:17:58 PST 2000 (added instrument selection)
// Last Modified: Tue Feb 20 19:20:09 PST 2001 (add articulation interpretation)
// Filename:      ...sig/examples/all/smf.cpp
// Web Address:   http://sig.sapp.org/examples/museinfo/humdrum/smf.cpp
// Syntax:        C++; museinfo
//
// Description:   Converts Humdrum **kern data into MIDI data in a
//                Standard MIDI File format.
//

#include "museinfo.h"

#include <string.h>
#include <stdio.h>


// global variables:
const char *outlocation = NULL;
int   trackcount  = 0;           // number of tracks in MIDI file
int   track       = 0;           // track number starting at 0
int   offset      = 0;           // start-time offset in ticks
int   tempo       = 60;          // default tempo

// user interface variables
Options options;
int     storeCommentQ    =  1;    // used with the -C option
int     storeTextQ       =  1;    // used with the -T option
int     plusQ            =  0;    // used with the --plus option
int     defaultvolume    = 64;    // used with the -v option
double  tscaling         =  1.0;  // used with the -s option
int     multitimbreQ     =  1;    // used with the -c option
int     instrumentQ      =  1;    // used with the -I option
int     fixedChannel     =  0;    // used with the -c option
int     instrumentnumber = -1;    // used with the -f option
int     forcedQ          =  0;    // used with the -f option
int     mine             =  0;    // used with the -m option
int     shortenQ         =  0;    // used with the -s option
int     shortenamount    =  0;    // used with the -s option
int     plainQ           =  0;    // used with the -p option
int     debugQ           =  0;    // used with the --debug option

// function declarations:
void      assignTracks      (HumdrumFile& infile, Array<int>& trackchannel);
double    checkForTempo     (HumdrumRecord& record);
void      checkOptions      (Options& opts, int argc, char** argv);
void      example           (void);
int       makeVLV           (uchar *buffer, int number);
void      reviseInstrumentMidiNumbers(const char* string);
int       setMidiPlusVolume (const char* kernnote);
void      storeMetaText     (MidiFile& mfile, int track, const char* string, 
                               int tick, int metaType = 1);
void      storeMidiData     (HumdrumFile& infile, MidiFile& outfile);
void      storeInstrument   (int ontick, MidiFile& mfile, HumdrumFile& infile, 
                             int i, int j, int pcQ);
void      usage             (const char* command);


Array<int> tracknamed;      // for storing boolean if track is named
Array<int> trackchannel;    // channel of each track

//////////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[]) {
   HumdrumFile infile;
   MidiFile    outfile;

   outfile.setTicksPerQuarterNote(120);

   // process the command-line options
   checkOptions(options, argc, argv);

   // figure out the number of input files to process
   int numinputs = options.getArgCount();

   for (int i=0; i<numinputs || i==0; i++) {
      infile.clear();

      // if no command-line arguments read data file from standard input
      if (numinputs < 1) {
         infile.read(cin);
      } else {
         infile.read(options.getArg(i+1));
      }

      // analyze the input file according to command-line options
      infile.analyzeRhythm("4");

      trackcount = infile.getMaxTracks();
      tracknamed.setSize(trackcount + 1);
      trackchannel.setSize(trackcount + 1);
      for (int j=0; j<trackcount+1; j++) {
         tracknamed[j]   = 0;
         trackchannel[j] = fixedChannel;
      }
      if (multitimbreQ) {
         assignTracks(infile, trackchannel);
      }
      outfile.addTrack(trackcount);
      outfile.absoluteTime();

      /*
      // removed this code because of all of the lousy free MIDI 
      // sequencing programs that choke on system exclusive messages.

      // store the "General MIDI activation" system exclusive:
      // don't bother if this is just a Type 0 MIDI file
      // because some lame linux sequencers crash on system exclusives
      // (kmidi)
      if (!options.getBoolean("type0")) {
         Array<uchar> gmsysex;
         gmsysex.setSize(6);
         gmsysex[0] = 0xf0;     // Start of SysEx
         gmsysex[1] = 0x7e;     // Universal (reserved) ID number 
         gmsysex[2] = 0x7f;     // Device ID (general transmission)
         gmsysex[3] = 0x09;     // Means 'This is a message about General MIDI' 
         gmsysex[4] = 0x01;     // Means 'Turn General MIDI On'. 02 means 'Off' 
         gmsysex[5] = 0xf7;     // End of SysEx
         outfile.addEvent(0, 0, gmsysex);
      }
      */ 

      storeMidiData(infile, outfile);

      if (outlocation == NULL) {
         outfile.sortTracks();
         cout << outfile;
      } else {
         outfile.sortTracks();
         outfile.write(outlocation);
      }
   }

   return 0;
}


//////////////////////////////////////////////////////////////////////////

//////////////////////////////
//
// assignTracks -- give a track number for each spine in the input file
//    trying to place the same instruments into the same channels if
//    there are not enough channels to go around.
//

void assignTracks(HumdrumFile& infile, Array<int>& trackchannel) {
   int i, j;
   Array<int> instruments;        // MIDI instruments indicated in track
   trackchannel.setSize(infile.getMaxTracks() + 1);
   instruments.setSize(trackchannel.getSize());
   for (i=0; i<instruments.getSize(); i++) {
      if (forcedQ) {
         instruments[i] = instrumentnumber;
      } else {
         instruments[i] = -1;
      }
      trackchannel[i] = 0;
   }
   HumdrumInstrument x;
   int inst = -1;
   int ptrack = 0;
   int instcount = 0;

   for (i=0; i<infile.getNumLines(); i++) {
      if (debugQ) {
         cout << "line " << i+1 << ":\t" << infile[i] << endl;
      }

      if (infile[i].getType() != E_humrec_interpretation) {
         continue;
      }

      for (j=0; j<infile[i].getFieldCount(); j++) {
         if (strncmp(infile[i][j], "*I", 2) == 0) {
            if (!forcedQ) {
               inst = x.getGM(infile[i][j]);
            } else {
               inst = instrumentnumber;
            }
         }

         if (inst != -1) {
            ptrack = infile[i].getPrimaryTrack(j);
            if (instruments[ptrack] == -1) {
               if (!forcedQ) {
                  instruments[ptrack] = inst;
               } else {
                  instruments[ptrack] = instrumentnumber;
               }
               instcount++;
            } 
         }
      }
   }

   int nextChannel = 0;        // next midi channel available to assign

   if (instcount < 15) {
      // have enough space to store each instrument on a separate channel
      // regardless of instrumentation
      nextChannel = 1;        // channel 0 is for undefined instrument spines
      for (i=0; i<instruments.getSize(); i++) {
         if (instruments[i] == -1) {
            trackchannel[i] = 0;
         } else {
            trackchannel[i] = nextChannel++;
         }

         // avoid General MIDI percussion track.
         if (nextChannel == 9) {
            nextChannel++;
         }
      }
   } else {
      // need to conserve channels:  place duplicate instrument tracks on the 
      // same channel.
      nextChannel = 1;     // channel 0 is for undefined instrument spines
      int foundDup = -1;
      for (i=0; i<instruments.getSize(); i++) {
         foundDup = -1;
         for (j=0; j<i; j++) {
            if (instruments[j] == instruments[i]) {
               foundDup = j; 
            }
         }
         if (instruments[i] == -1) {
            trackchannel[i] = 0;
         } else if (foundDup != -1) {
            trackchannel[i] = trackchannel[foundDup];
         } else {
            trackchannel[i] = nextChannel++;
         }

         // avoid General MIDI percussion track.
         if (nextChannel == 9) {
            nextChannel++;
         }
      }

      if (nextChannel > 16) {
         // channel allocation is over quota: squash over-allocations:
         for (i=0; i<trackchannel.getSize(); i++) {
            if (trackchannel[i] > 15) {
               trackchannel[i] = 0;
            }
         }
      }

   }

}



//////////////////////////////
//
// checkForTempo --
//

double checkForTempo(HumdrumRecord& record) {
   int i;
   float tempo = 60.0;
   for (i=0; i<record.getFieldCount(); i++) {
      if (strncmp(record[i], "*MM", 3) == 0) {
         sscanf(&(record[i][3]), "%f", &tempo);
         return (double)tempo * tscaling;
      }
   }

   return -1.0;
}



//////////////////////////////
//
// checkOptions -- 
//

void checkOptions(Options& opts, int argc, char* argv[]) {
   opts.define("C|nocomments=b",  "don't store comments as meta text");
   opts.define("n|note|comment=s", "store a comment line in the file");
   opts.define("T|notext=b",      "don't non-musical data as meta text");
   opts.define("o|output=s:midi.mid", "output midifile");
   opts.define("0|O|type0|zero=b", "generate a type 0 MIDI file");
   opts.define("plus=b",          "create a MIDIPlus compliant MIDI file");
   opts.define("v|volume=i:64",   "default attack velocity");
   opts.define("t|tempo-scaling=d:1.0", "tempo scaling");
   opts.define("I|noinstrument=b", "don't store MIDI instrument programs");
   opts.define("i|instruments=s", "specify MIDI conversions for instruments");
   opts.define("f|forceinstrument=i:0", "MIDI instrument for all tracks");
   opts.define("c|channel=i:-1",   "channel to store for MIDI data");
   opts.define("m|min=i:0",        "minimum tick duration of notes");
   opts.define("s|shorten=i:0",    "shortening tick value for note durations");
   opts.define("p|plain=b",        "play with articulation interpretation");
   opts.define("debug=b",          "debugging turned on");

   opts.define("author=b",  "author of program"); 
   opts.define("version=b", "compilation info");
   opts.define("example=b", "example usages");   
   opts.define("h|help=b",  "short description");
   opts.process(argc, argv);
   
   // handle basic options:
   if (opts.getBoolean("author")) {
      cout << "Written by Craig Stuart Sapp, "
           << "craig@ccrma.stanford.edu, May 1998" << endl;
      exit(0);
   } else if (opts.getBoolean("version")) {
      cout << argv[0] << ", version: April 2002" << endl;
      cout << "compiled: " << __DATE__ << endl;
      cout << MUSEINFO_VERSION << endl;
      exit(0);
   } else if (opts.getBoolean("help")) {
      usage(opts.getCommand());
      exit(0);
   } else if (opts.getBoolean("example")) {
      example();
      exit(0);
   }

   if (opts.getBoolean("instruments")) {
      reviseInstrumentMidiNumbers(opts.getString("instruments"));
   }

   if (opts.getBoolean("nocomments")) {
      storeCommentQ = 0;
   } else {
      storeCommentQ = 1;
   }

   if (opts.getBoolean("notext")) {
      storeTextQ = 0;
   } else {
      storeTextQ = 1;
   }

   if (opts.getBoolean("plus")) {
      plusQ = 1;
   } else {
      plusQ = 0;
   }

   defaultvolume = opts.getInt("volume");
   if (defaultvolume < 1) {
      defaultvolume = 1;
   } else if (defaultvolume > 127) {
      defaultvolume = 127;
   }
   
   tscaling = opts.getDouble("tempo-scaling");
   if (tscaling < 0.001) {
      tscaling = 1.0;
   } else if (tscaling > 1000.0) {
      tscaling = 1.0; 
   }
   instrumentQ = !opts.getBoolean("noinstrument");

   if (opts.getBoolean("channel")) {
      multitimbreQ = 0;
      fixedChannel = opts.getInteger("channel") - 1;
      if (fixedChannel < 0) {
         fixedChannel = 0;
      } 
      if (fixedChannel > 15) {
         fixedChannel = 15;
      } 
      instrumentQ = 0;
   } else {
      multitimbreQ  = 1;
      fixedChannel = -1;
   }

   if (opts.getBoolean("output")) {
      outlocation = opts.getString("output");
   } else {
      outlocation = NULL;
   }

   forcedQ = opts.getBoolean("forceinstrument");
   if (forcedQ) {
      instrumentnumber = opts.getInteger("forceinstrument");
      if (instrumentnumber < 0 || instrumentnumber > 127) {
         instrumentnumber = 0;
      } 
   } else {
      instrumentnumber = -1;
   }

   mine = opts.getInteger("min");
   if (mine < 0) {
      mine = 0;
   }
   debugQ        = opts.getBoolean("debug");
   shortenQ      = opts.getBoolean("shorten");
   shortenamount = opts.getInteger("shorten");

}



//////////////////////////////
//
// example --
//

void example(void) {

}



//////////////////////////////
//
// storeMetaText --
//

void storeMetaText(MidiFile& mfile, int track, const char* string, int tick,
      int metaType) {
   int i;
   int length = strlen(string);
   Array<uchar> metadata;
   uchar size[23] = {0};
   int lengthsize =  makeVLV(size, length);

   metadata.setSize(2+lengthsize+length);
   metadata[0] = 0xff;
   metadata[1] = metaType;
   for (i=0; i<lengthsize; i++) {
      metadata[2+i] = size[i];
   }
   for (i=0; i<length; i++) {
      metadata[2+lengthsize+i] = string[i];
   }

   mfile.addEvent(track, tick + offset, metadata);
}



//////////////////////////////
//
// makeVLV -- 
//

int makeVLV(uchar *buffer, int number) {
   unsigned long value = (unsigned long)number;

   if (value >= (1 << 28)) {
      cout << "Error: number too large to handle" << endl; 
      exit(1);
   }
  
   buffer[0] = (value >> 21) & 0x7f;
   buffer[1] = (value >> 14) & 0x7f;
   buffer[2] = (value >>  7) & 0x7f;
   buffer[3] = (value >>  0) & 0x7f;

   int i;
   int flag = 0;
   int length = -1;
   for (i=0; i<3; i++) {
      if (buffer[i] != 0) {
         flag = 1;
      }
      if (flag) {
         buffer[i] |= 0x80;
      }
      if (length == -1 && buffer[i] >= 0x80) {
         length = 4-i;
      }
   }

   if (length == -1) {
      length = 1;
   }

   if (length < 4) {
      for (i=0; i<length; i++) {
         buffer[i] = buffer[4-length+i];
      }
   }

   return length;
}
            


//////////////////////////////
//
// storeMidiData --
//

void storeMidiData(HumdrumFile& infile, MidiFile& outfile) {
   double duration = 0.0;
   int midinote = 0;
   double absbeat = 0.0;
   int ontick = 0;
   int offtick = 0;
   Array<uchar> mididata;
   int i, j, k;
   int tokencount = 0;
   char buffer1[1024] = {0};
   int staccatoQ = 0;
   int accentQ = 0;
   int sforzandoQ = 0;
   int volume = defaultvolume;
   int ttempo;

   if (tscaling != 1.0) {
      ttempo = (int)(60 * tscaling);
      if (ttempo > 0) {
         mididata.setSize(6);
         mididata[0] = 0xff;
         mididata[1] = 0x51;
         mididata[2] = 3;
         ttempo = (int)(60000000.0 / ttempo + 0.5);   
         mididata[3] = (uchar)((ttempo >> 16) & 0xff);
         mididata[4] = (uchar)((ttempo >> 8) & 0xff);
         mididata[5] = (uchar)(ttempo & 0xff);
         outfile.addEvent(0, 0 + offset, mididata);
      }
   }

   if (options.getBoolean("comment")) {
      storeMetaText(outfile, 0, options.getString("comment"), 0);
   }

   for (i=0; i<infile.getNumLines(); i++) {
      if (debugQ) {
         cout << "Line " << i+1 << ":\t" << infile[i] << endl;
      }

      if (storeCommentQ && (infile[i].getType() == E_humrec_global_comment)) {
         absbeat = infile.getAbsBeat(i);
         ontick = int(absbeat * outfile.getTicksPerQuarterNote());
         storeMetaText(outfile, 0, infile[i].getLine(), ontick);
      } else if (storeTextQ && (infile[i].getType() == E_humrec_bibliography)) {
         absbeat = infile.getAbsBeat(i);
         ontick = int(absbeat * outfile.getTicksPerQuarterNote());
         if (strncmp(&(infile[i].getLine()[3]), "YEC", 3) == 0) {
            storeMetaText(outfile, 0, infile[i].getLine(), ontick, 2);
         } else if (strncmp(&(infile[i].getLine()[3]), "OTL", 3) == 0) {
            storeMetaText(outfile, 0, infile[i].getLine(), ontick, 3);
         } else if (storeCommentQ) {
            storeMetaText(outfile, 0, infile[i].getLine(), ontick);
         }
      } else if (infile[i].getType() == E_humrec_interpretation) {

         if (infile[i].getType() == E_humrec_interpretation) {
            tempo = (int)checkForTempo(infile[i]);
            ttempo = (int)(tempo * tscaling + 0.5);
            if (ttempo > 0) {
               mididata.setSize(6);
               mididata[0] = 0xff;
               mididata[1] = 0x51;
               mididata[2] = 3;
               ttempo = (int)(60000000.0 / ttempo + 0.5);   
               mididata[3] = (uchar)((ttempo >> 16) & 0xff);
               mididata[4] = (uchar)((ttempo >> 8) & 0xff);
               mididata[5] = (uchar)(ttempo & 0xff);
               absbeat = infile.getAbsBeat(i);
               ontick = int(absbeat * outfile.getTicksPerQuarterNote());
               outfile.addEvent(0, ontick + offset, mididata);
               outfile.addEvent(0, 10 + offset, mididata);
            }
         }

         for (j=0; j<infile[i].getFieldCount(); j++) {
            absbeat = infile.getAbsBeat(i);
            ontick = int(absbeat * outfile.getTicksPerQuarterNote());
            int track = infile[i].getPrimaryTrack(j);

            if (strcmp(infile[i][j], "**kern") == 0 && forcedQ) {
               Array<uchar> mididata;
               mididata.setSize(2);
               mididata[0] = 0xc0 | (0x0f & trackchannel[track]);
               mididata[1] = instrumentnumber;
               outfile.addEvent(track, ontick + offset, mididata);
               continue;
            }

            if (strncmp(infile[i][j], "*I", 2) == 0) {
               storeInstrument(ontick, outfile, infile, i, j, instrumentQ);
               continue;
            } 

         }
      } else if (infile[i].getType() == E_humrec_data) {
         for (j=0; j<infile[i].getFieldCount(); j++) {
            if (strcmp(infile[i][j], ".") == 0) {
               continue;
            }

            if (infile[i].getExInterpNum(j) != E_KERN_EXINT) {
               absbeat = infile.getAbsBeat(i);
               ontick = int(absbeat * outfile.getTicksPerQuarterNote());
               track = infile[i].getPrimaryTrack(j);
               if (storeTextQ) {
                  storeMetaText(outfile, track, infile[i][j], ontick);
               }
               continue;
            } else {
               track = infile[i].getPrimaryTrack(j);
               tokencount = infile[i].getTokenCount(j);
               for (k=0; k<tokencount; k++) {
                  infile[i].getToken(buffer1, j, k); 

                  // skip tied notes
                  if (strchr(buffer1, '_') || strchr(buffer1, ']')) {
                     continue;
                  }

                  if (strchr(buffer1, '[')) {
                     // total tied note durations
                     duration = infile.getTiedDuration(i, j, k);
                  } else {
                     duration = Convert::kernToDuration(buffer1);
                  }
                  midinote = Convert::kernToMidiNoteNumber(buffer1); 
                  // skip rests
                  if (midinote < 0) {
                     continue;
                  }

                  accentQ = (int)strchr(buffer1, '^');
                  sforzandoQ = (int)strchr(buffer1, 'z');
                  staccatoQ = (int)strchr(buffer1, '\'');

                  if (shortenQ) {
                     duration -= shortenamount;
                     if (duration < mine) {
                        duration = mine;
                     }
                  }

                  if (staccatoQ) {
                     duration = duration * 0.5;
                  }
                  if (accentQ) {
                     volume = (int)(defaultvolume * 1.3 + 0.5);
                  }
                  if (sforzandoQ) {
                     volume = (int)(defaultvolume * 1.5 + 0.5);
                  }
   
                  if (plusQ) {
                     volume = setMidiPlusVolume(buffer1);
                  }
                  absbeat = infile.getAbsBeat(i);
                  ontick = int(absbeat * outfile.getTicksPerQuarterNote());
                  offtick = int(duration * outfile.getTicksPerQuarterNote()) + 
                     ontick;
                  if (shortenQ) {
                     offtick -= shortenamount;
                     if (offtick - ontick < mine) {
                        offtick = ontick + mine;
                     }
                  }

                  if (volume < 0) {
                     volume = 1;
                  }
                  if (volume > 127) {
                     volume = 127;
                  }
                  mididata.setSize(3);
                  mididata[0] = 0x90 | trackchannel[track];
                  mididata[1] = midinote;
                  mididata[2] = volume;
                  outfile.addEvent(track, ontick + offset, mididata);
                  mididata[0] = 0x80 | trackchannel[track];
                  outfile.addEvent(track, offtick + offset, mididata);
               }
            }
         }
      }
   }

   // now add the end-of-track message to all tracks so that they
   // end at the same time
   mididata.setSize(3);
   mididata[0] = 0xff;
   mididata[1] = 0x2f;
   mididata[2] = 0x00;
   
   absbeat = infile.getAbsBeat(infile.getNumLines()-1);
   ontick = int(absbeat * outfile.getTicksPerQuarterNote());

   if (options.getBoolean("type0")) {
      outfile.joinTracks();
      outfile.addEvent(0, ontick, mididata);
   } else {  // type 1 MIDI file
      int trackcount = outfile.getNumTracks();
      for (i=0; i<trackcount; i++) {
         outfile.addEvent(i, ontick, mididata);
      }
   }
}



//////////////////////////////
//
// reviseInstrumentMidiNumbers --
//

void reviseInstrumentMidiNumbers(const char* string) {
   const char* spaces = " \t\n,:;";
   char* buffer = new char[strlen(string) + 1];
   strcpy(buffer, string);
   HumdrumInstrument x;

   char* pointer = buffer;
   pointer = strtok(buffer, spaces);
   int instnum = 0;
   while (pointer != NULL) {
      char* humdrumname = pointer;
      pointer = strtok(NULL, spaces);
      if (pointer == NULL) {
         break;
      }
      instnum = 0;
      sscanf(pointer, "%d", &instnum);
      
      if (instnum < 0 || instnum > 127) {
         continue;
      }
      x.setGM(humdrumname, instnum);
      pointer = strtok(NULL, spaces);
   }
}



//////////////////////////////
//
// setMidiPlusVolume -- store slur and enharmonic spelling information.
//    based on definition in the book:
//       Beyond MIDI: The Handbook of Musical Codes. pp. 99-104.
//

int setMidiPlusVolume(const char* kernnote) {
   int output = 1 << 6;

   // check for slurs, but do not worry about separating multiple slurs
   if (strchr(kernnote, '(') != NULL) {
      // start of slur A
      output |= (1 << 2);
   } else if (strchr(kernnote, ')') != NULL) {
      // end of slur A
      output |= (1 << 4);
   }

   // set the accidental marking
   int base40class = Convert::kernToBase40(kernnote) % 40;
   int midinoteclass = Convert::kernToMidiNoteNumber(kernnote) % 12;

   int acheck = 0;
   switch (midinoteclass) {
      case 0:                           // C/Dbb/B#
         switch (base40class) {
            case  4: acheck = 1; break;  // Dbb
            case  0: acheck = 2; break;  // C
            case 36: acheck = 3; break;  // B#
            default: acheck = 0;
         }
         break;
      case 1:                           // C#/Db/B##
         switch (base40class) {
            case  5: acheck = 1; break;  // Db
            case  1: acheck = 2; break;  // C#
            case 37: acheck = 3; break;  // B##
            default: acheck = 0;
         }
         break;
      case 2:                           // D/C##/Ebb
         switch (base40class) {
            case 10: acheck = 1; break;  // Ebb
            case  6: acheck = 2; break;  // D
            case  2: acheck = 3; break;  // C##
            default: acheck = 0;
         }
         break;
      case 3:                           // D#/Eb/Fbb
         switch (base40class) {
            case 15: acheck = 1; break;  // Fbb
            case 11: acheck = 2; break;  // Eb
            case  7: acheck = 3; break;  // D#
            default: acheck = 0;
         }
         break;
      case 4:                           // E/Fb/D##
         switch (base40class) {
            case 16: acheck = 1; break;  // Fb
            case 12: acheck = 2; break;  // E
            case  8: acheck = 3; break;  // D##
            default: acheck = 0;
         }
         break;
      case 5:                           // F/E#/Gbb
         switch (base40class) {
            case 21: acheck = 1; break;  // Gbb
            case 17: acheck = 2; break;  // F
            case 13: acheck = 3; break;  // E#
            default: acheck = 0;
         }
         break;
      case 6:                           // F#/Gb/E##
         switch (base40class) {
            case 22: acheck = 1; break;  // Gb
            case 18: acheck = 2; break;  // F#
            case 14: acheck = 3; break;  // E##
            default: acheck = 0;
         }
         break;
      case 7:                           // G/Abb/F##
         switch (base40class) {
            case 27: acheck = 1; break;  // Abb
            case 23: acheck = 2; break;  // G
            case 19: acheck = 3; break;  // F##
            default: acheck = 0;
         }
         break;
      case 8:                           // G#/Ab/F###
         switch (base40class) {
            case 28: acheck = 1; break;  // Ab
            case 24: acheck = 2; break;  // G#
            default: acheck = 0;         // F###
         }
         break;
      case 9:                           // A/Bbb/G##
         switch (base40class) {
            case 33: acheck = 1; break;  // Bbb
            case 29: acheck = 2; break;  // A
            case 25: acheck = 3; break;  // G##
            default: acheck = 0;
         }
         break;
      case 10:                           // Bb/A#/Cbb
         switch (base40class) {
            case 38: acheck = 1; break;  // Cbb
            case 34: acheck = 2; break;  // Bb
            case 30: acheck = 3; break;  // A#
            default: acheck = 0;
         }
         break;
      case 11:                           // B/Cf/A##
         switch (base40class) {
            case 39: acheck = 1; break;  // Cb
            case 35: acheck = 2; break;  // B
            case 31: acheck = 3; break;  // A##
            default: acheck = 0;
         }
         break;
   }
     
   output |= acheck;
   return output; 
}



//////////////////////////////
//
// storeInstrument --
//

void storeInstrument(int ontick, MidiFile& mfile, HumdrumFile& infile, 
      int i, int j, int pcQ) {
   static HumdrumInstrument huminst;
   int track = infile[i].getPrimaryTrack(j);
   const char* trackname = huminst.getName(infile[i][j]);
   int pc = huminst.getGM(infile[i][j]);
   if (forcedQ) {
      pc = instrumentnumber;
   }
   int channel = 0x0f & trackchannel[track];   

   // store the program change if requested:
   
   Array<uchar> mididata;
   mididata.setSize(2);
   mididata[0] = 0xc0 | channel;
   mididata[1] = (uchar)pc;
   if (pcQ && pc >= 0 && !forcedQ) {
      mfile.addEvent(track, ontick + offset, mididata);
   }

   if (!tracknamed[track]) {
      tracknamed[track] = 1;
      storeMetaText(mfile, track, trackname, 0, 3);    // Track Name
   }
   storeMetaText(mfile, track, trackname + offset, ontick, 4);  // Inst. Name

}



//////////////////////////////
//
// usage --
//

void usage(const char* command) {

}