Ejemplo n.º 1
0
 public Instrument getInstrument(Patch patch) {
   int program = patch.getProgram();
   int bank = patch.getBank();
   boolean percussion = false;
   if (patch instanceof ModelPatch) percussion = ((ModelPatch) patch).isPercussion();
   for (Instrument instrument : instruments) {
     Patch patch2 = instrument.getPatch();
     int program2 = patch2.getProgram();
     int bank2 = patch2.getBank();
     if (program == program2 && bank == bank2) {
       boolean percussion2 = false;
       if (patch2 instanceof ModelPatch) percussion2 = ((ModelPatch) patch2).isPercussion();
       if (percussion == percussion2) return instrument;
     }
   }
   return null;
 }
Ejemplo n.º 2
0
  public static void main(String[] args) throws Exception {

    synth = MidiSystem.getSynthesizer();
    synth.open();
    synth.loadAllInstruments(synth.getDefaultSoundbank());
    //        int s = 0;
    //        for(Instrument i : synth.getAvailableInstruments()){
    //            System.out.println(s+" "+i.getName());
    //            s++;
    //        }
    chan = synth.getChannels()[0];
    for (Instrument i : synth.getLoadedInstruments())
      if (i.getName().toLowerCase().trim().contains("sine"))
        chan.programChange(i.getPatch().getProgram());

    if (chan.getProgram() == 0)
      JOptionPane.showMessageDialog(null, "Could not find a valid instrument. Sound is disabled");
    // chan.programChange(synth.getLoadedInstruments()[197].getPatch().getProgram());

    for (int i = 0; i < array.length; i++) marked.add(-5);
    rianr(array);
    window.setSize(new Dimension(640, 480));
    window.setLocation(0, 0);
    window.setVisible(true);
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    window.setTitle("Array Visualizer");

    uf = new UtilFrame(window);

    // AUDIO THREAD
    new Thread() {
      @Override
      public void run() {
        while (true) {
          chan.allNotesOff();
          if (SOUND == false) {
            continue;
          }

          int tmp = 1;
          for (int i : marked) if (i != -5) tmp++;
          for (int i : marked)
            if (i != -5) {
              int pitch =
                  (int)
                      Math.round(
                          (double) array[Math.min(Math.max(i, 0), array.length - 1)]
                                  / array.length
                                  * 96
                              + 16);
              // int vel = (int)(((128-pitch)/320.0+0.4)   *   (128.0/Math.pow(tmp,0.33)));
              int vel = (int) (64.0 / Math.pow(tmp, 0.5));
              chan.noteOn(pitch, vel);
            }
          // ((int)((127-(array[Math.min(Math.max(i,
          // 0),array.length-1)]/16.0))/Math.sqrt(calcVel())))*5
          // double tmp = (array[Math.min(Math.max(i, 0),array.length-1)]/32.0+47);
          // chan.setPitchBend(8192*2-(int)((tmp-Math.floor(tmp))*8192*2));
          /*
          ArrayList<Integer> tmp = new ArrayList<Integer>();
          for(int i : marked)
              if(i != -5)
                  tmp.add(i);

          if(tmp.size() > 0){
              do{
                  int i = tmp.get(snd%tmp.size());
                  snd++;
              chan.noteOn(array[Math.min(Math.max(i, 0),array.length-1)]/32+47, 127);
              double tmpd = (array[Math.min(Math.max(i, 0),array.length-1)]/32.0+47);
              chan.setPitchBend(8192*2-(int)((tmpd-Math.floor(tmpd))*8192*2));
              }while(false);}*/
          try {
            sleep(1);
          } catch (Exception e) {
          }
        }
      }
    }.start();

    // DRAW THREAD
    new Thread() {
      @Override
      public void run() {
        int cw = window.getWidth();
        int ch = window.getHeight();
        Image img = window.createVolatileImage(cw, ch);
        // Graphics g = window.getGraphics();
        Graphics g = img.getGraphics();
        double xscl, yscl;
        while (true) {

          if (window.getWidth() != cw
              || window.getHeight() != ch
              || window.getX() != cx
              || window.getY() != cy) {
            uf.reposition();
            if (v != null && v.isVisible()) v.reposition();
            cx = window.getX();
            cy = window.getY();
          }

          if (window.getWidth() != cw || window.getHeight() != ch) {
            cw = window.getWidth();
            ch = window.getHeight();
            img = window.createVolatileImage(cw, ch);
            fon = new Font("TimesRoman", Font.PLAIN, (int) (cw / 1280.0 * 25));
            g = img.getGraphics();
          }
          int gamt = 32; // (int)(frames/1000.0%64);
          g.setColor(new Color(gamt, gamt, gamt));
          g.fillRect(0, 0, img.getWidth(null), img.getHeight(null));
          xscl = (double) window.getWidth() / array.length;
          yscl = (double) (window.getHeight() - 30) / array.length;
          int amt = 0;
          int circamt = array.length / 2;
          frames++;
          if (CIRCLEDRAW)
            for (int i = 0; i < array.length; i++) {
              if (marked.contains(i)
                  || marked.contains(i - 1)
                  || marked.contains(i - 2)
                  || marked.contains(i - 3)) g.setColor(Color.BLACK);
              else g.setColor(getIntColor(array[i]));
              // COLOR ONLY NO LENGTH
              if (COLORONLY)
                g.drawLine(
                    window.getWidth() / 2,
                    window.getHeight() / 2,
                    window.getWidth() / 2
                        + (int) (Math.sin(i * Math.PI / circamt) * (window.getWidth() - 64) / 2.0),
                    window.getHeight() / 2
                        - (int)
                            (Math.cos(i * Math.PI / circamt) * (window.getHeight() - 96) / 2.0));
              else if (PIXELDRAW)
                g.fillRect(
                    window.getWidth() / 2
                        + (int)
                            (Math.sin(i * Math.PI / circamt)
                                * ((window.getWidth() - 64)
                                    / 2.0
                                    * (array[i] / (double) array.length))),
                    window.getHeight() / 2
                        - (int)
                            (Math.cos(i * Math.PI / circamt)
                                * ((window.getHeight() - 96)
                                    / 2.0
                                    * (array[i] / (double) array.length))),
                    (int) (2 * (window.getWidth() / 640.0)),
                    (int) (2 * (window.getHeight() / 480.0)));
              // LENGTH AND COLOR
              else
                g.drawLine(
                    window.getWidth() / 2,
                    window.getHeight() / 2,
                    window.getWidth() / 2
                        + (int)
                            (Math.sin(i * Math.PI / circamt)
                                * ((window.getWidth() - 64)
                                    / 2.0
                                    * (array[i] / (double) array.length))),
                    window.getHeight() / 2
                        - (int)
                            (Math.cos(i * Math.PI / circamt)
                                * ((window.getHeight() - 96)
                                    / 2.0
                                    * (array[i] / (double) array.length))));
            }
          else
            for (int i = 0; i < array.length; i++) {
              if (marked.contains(i)
                  || marked.contains(i - 1)
                  || marked.contains(i - 2)
                  || marked.contains(i - 3)) g.setColor(Color.BLACK);
              else g.setColor(getIntColor(array[i]));

              int y = 0;
              int width = (int) (xscl * i) - amt;

              if (width > 0) {
                if (COLORONLY) {
                  y = (int) (window.getHeight() - 750 * yscl);
                  g.fillRect(amt, y, width, Math.max((int) (750 * yscl), 1));
                  g.setColor(getRevColor());
                  g.fillRect((int) (i * xscl), y, width, 6);
                } else if (PIXELDRAW) {
                  y = (int) (window.getHeight() - array[i] * yscl);
                  g.fillRect(amt, y, width, 3);
                } else {
                  y = (int) (window.getHeight() - array[i] * yscl);
                  g.fillRect(amt, y, width, Math.max((int) (array[i] * yscl), 1));
                  g.setColor(getRevColor());
                  g.fillRect(amt, y, width, 6);
                }
              }
              amt += width;
            }

          int coltmp = 255; // (int)Math.abs(Math.sin(frames*0.01)*255);
          g.setColor(new Color(coltmp, coltmp, coltmp));
          Font f = g.getFont();
          g.setFont(fon);
          g.drawString(heading, 10, (int) (cw / 1280.0 * 20) + 30);
          g.drawString(
              "Comparisons: " + comps + " Array Accesses: " + aa,
              10,
              (int) (cw / 1280.0 * 40) + 30);
          g.setFont(f);
          Graphics g2 = window.getGraphics();
          g2.setColor(Color.BLACK);
          g2.drawImage(img, 0, 0, null);
        }
      }

      public Color getIntColor(int i) {
        return Color.getHSBColor(((float) i / array.length), 1.0F, 0.8F);
      }

      public Color getRevColor() {
        return getIntColor((int) (Math.sin(frames / 66.67) * array.length));
      }
    }.start();

    uf.setVisible(false);
    v = new ViewPrompt(window);
    while (v.isVisible()) Thread.sleep(1);
    uf.setVisible(true);

    // bogoSort();
    //        while(true){
    //            clearmarked();
    //
    //            //heading = "Linear Search";
    //
    //            //Arrays.sort(array);
    //            //marked.set(1,730);
    //            //linearSearch(730);
    //            //refresharray();
    //
    //            //heading = "Binary Search";
    //
    //            //Arrays.sort(array);
    //            //marked.set(1, 730);
    //            //binarySearch(730);
    //
    //            //heading = "Shatter-Time Sort";
    //
    //            //timeSort();
    //
    //            //chan.allNotesOff();
    //            //refresharray();
    //            weaveMergeSort(0, array.length-1);
    //            refresharray();
    //            cocktailShakerSort();
    //            refresharray();
    //            radixLSDsort(4);
    //            refresharray()
    //  ;RadixLSDInPlace.inPlaceRadixLSDSort(10);refresharray();
    //
    //            heading = "Insertion Sort";
    //
    //            insertionSort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Bubble Sort";
    //
    //            bubbleSort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Selection Sort";
    //
    //            selectionSort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Cocktail Shaker Sort";
    //
    //            cocktailShakerSort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Double Selection Sort";
    //
    //            doubleSelectionSort(array);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Merge Sort In-Place";
    //
    //            mergeSort(0, array.length - 1);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Merge Sort Out-of-Place";
    //
    //            mergeSortOP();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //
    //            heading = "Gravity Sort (Abacus/Bead)";
    //
    //            gravitySort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //
    //            heading = "Quick Sort";
    //
    //            quickSort(array, 0, array.length-1);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Counting Sort";
    //
    //            countingSort();
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Radix LSD Sort";
    //
    //            radixLSDsort(4);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Radix LSD In-Place Sort";
    //
    //            inPlaceRadixLSDSort(10);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            heading = "Radix MSD Sort";
    //
    //            radixMSDSort(4);
    //            refresharray();
    //            //heading = "Shatter Partition";
    //
    //            //shatterPartition(1);
    //
    //            //chan.allNotesOff();
    //            //refresharray();
    //            heading = "Shatter Sort";
    //
    //            shatterSort(128);
    //
    //            chan.allNotesOff();
    //            refresharray();
    //            //heading = "Simple Shatter Sort";
    //
    //            //simpleShatterSort(128, 4);
    //
    //            //chan.allNotesOff();
    //            //refresharray();
    //
    // keep on keeping on
    while (window.isActive()) Thread.sleep(1);
  }
Ejemplo n.º 3
0
  /**
   * Converts the given tune to a midi sequence.
   *
   * @param tune The tune to be converted.
   * @return The midi sequence of the tune.
   */
  public Sequence toMidiSequence(Tune tune) {
    Sequence sequence = null;
    try {
      if (instrument == null) {
        Synthesizer synth = MidiSystem.getSynthesizer();
        synth.open();
        try {
          setInstrument(synth.getAvailableInstruments()[0]);
        } finally {
          synth.close();
        }
      }
      // Sequence in ticks per quarter note : PPQ = Pulse Per Quarter Note
      // Resolution is expressed in ticks per beat.
      // Last parameter "1" is the number of tracks.
      sequence = new Sequence(Sequence.PPQ, SEQUENCE_RESOLUTION, 1);
      // Set the instrument on channel 0
      ShortMessage sm = new ShortMessage();
      sm.setMessage(ShortMessage.PROGRAM_CHANGE, 0, instrument.getPatch().getProgram(), 0);

      Track track = sequence.createTrack();
      track.add(new MidiEvent(sm, 0));
      // long trackLengthInTicks = track.ticks();
      int lastRepeatOpen = -1;
      int repeatNumber = 1;
      boolean inWrongEnding = false;
      KeySignature tuneKey = null;
      KeySignature currentKey = null;
      Hashtable partsKey = new Hashtable();

      long elapsedTime = 0;
      NoteAbstract[] graceNotes = null;
      Music staff = tune.getMusicForAudioRendition();
      Iterator it = staff.getVoices().iterator();
      while (it.hasNext()) {
        Voice voice = (Voice) it.next();
        int i = 0; // StaffItem iterator
        while (i < voice.size()) {
          if (!inWrongEnding) {
            // ==================================================================== TEMPO
            if (voice.elementAt(i) instanceof abc.notation.Tempo) {
              addTempoEventsFor(
                  track,
                  elapsedTime,
                  getMidiMessagesFor((Tempo) voice.elementAt(i))); // , trackLengthInTicks));
            } else
            /*if (voice.elementAt(i) instanceof abc.notation.PartLabel) {
            	//Imagine... part A in Gmaj, B in Amin
            	//in tune you have K:G, P:A, ... P:B, K:Am
            	//if you have part order ABA, when you return to A
            	//you stay in Amin. This stores the tuneKey when a
            	//new part appear, and restitute it when part is played again
            	abc.notation.PartLabel pl = (abc.notation.PartLabel) voice.elementAt(i);
            	if (partsKey.get(pl.getLabel()+"") == null) {
            		partsKey.put(pl.getLabel()+"", tuneKey);
            	} else {
            		tuneKey = (KeySignature) partsKey.get(pl.getLabel()+"");
            	}
            }
            else*/
            // ==================================================================== KEY SIGNATURE
            if (voice.elementAt(i) instanceof abc.notation.KeySignature) {
              tuneKey = (KeySignature) (voice.elementAt(i));
              currentKey = new KeySignature(tuneKey.getAccidentals());
            } else
            // ==================================================================== NOTE
            // Notes ending ties should be ignored. Already taken into
            // account in getNoteLengthInTicks(Note)
            if (voice.elementAt(i) instanceof abc.notation.Note
                && !((abc.notation.Note) voice.elementAt(i)).isEndingTie()) {

              Note note = (Note) voice.elementAt(i);
              long noteDuration;
              boolean fermata = false;
              Vector decorationNotes = new Vector();
              if (note.hasGeneralGracing() || note.hasDecorations()) {
                Decoration[] d = note.getDecorations();
                for (int j = 0; j < d.length; j++) {
                  switch (d[j].getType()) {
                    case Decoration.FERMATA:
                    case Decoration.FERMATA_INVERTED:
                      fermata = true;
                      break;
                    case Decoration.LOWERMORDENT:
                    case Decoration.UPPERMORDENT:
                    case Decoration.DOUBLE_LOWER_MORDANT:
                    case Decoration.DOUBLE_UPPER_MORDANT:
                    case Decoration.TRILL:
                    case Decoration.TURN: // GRUPETTO_UP
                    case Decoration.TURN_INVERTED: // GRUPETTO_DOWN
                    case Decoration.TURNX:
                    case Decoration.TURNX_INVERTED:
                      Note n = new Note(note.getHeight());
                      n.setAccidental(note.getAccidental(currentKey));
                      Note o =
                          new Interval(Interval.SECOND, Interval.MAJOR, Interval.UPWARD)
                              .calculateSecondNote(n);
                      Note m =
                          new Interval(Interval.SECOND, Interval.MAJOR, Interval.DOWNWARD)
                              .calculateSecondNote(n);
                      // TODO ornament templates: regular, musette, balkan...
                      // n.setStrictDuration(Note.SIXTEENTH);
                      // o.setDuration((short)(Note.EIGHTH+Note.SIXTEENTH));
                      o.setAccidental(Accidental.NONE);
                      m.setAccidental(Accidental.NONE);
                      n.setStrictDuration(Note.THIRTY_SECOND);
                      m.setStrictDuration(Note.THIRTY_SECOND);
                      o.setStrictDuration(Note.THIRTY_SECOND);
                      switch (d[j].getType()) {
                        case Decoration.DOUBLE_LOWER_MORDANT:
                          decorationNotes.add(n);
                          decorationNotes.add(m);
                        case Decoration.LOWERMORDENT:
                          decorationNotes.add(n);
                          decorationNotes.add(m);
                          break;
                        case Decoration.DOUBLE_UPPER_MORDANT:
                        case Decoration.TRILL:
                          decorationNotes.add(n);
                          decorationNotes.add(o);
                        case Decoration.UPPERMORDENT:
                          decorationNotes.add(n);
                          decorationNotes.add(o);
                          break;
                        case Decoration.TURNX_INVERTED:
                        case Decoration.TURN:
                          decorationNotes.add(o);
                          decorationNotes.add(n);
                          decorationNotes.add(m);
                          break;
                        case Decoration.TURNX:
                        case Decoration.TURN_INVERTED:
                          decorationNotes.add(m);
                          decorationNotes.add(n);
                          decorationNotes.add(o);
                      }
                      break;
                  }
                }
                // currently not used
                // future use: playing rolls, slides, etc.
              }
              long graceNotesDuration = 0;
              if (note.hasGracingNotes() || (decorationNotes.size() > 0)) {
                graceNotes = note.getGracingNotes();
                // gracing are eighth note for graphical rendition
                // and because that's it in the parser
                // adapt duration to note length
                int divisor = 1;
                if (note.getStrictDuration() >= Note.HALF) divisor = 1; // grace is an eighth
                else if (note.getStrictDuration() >= Note.QUARTER) divisor = 2; // 16th
                else if (note.getStrictDuration() >= Note.EIGHTH) divisor = 4; // 32nd
                else divisor = 8; // 64th
                if (note.hasGracingNotes()) {
                  for (int j = 0; j < graceNotes.length; j++) {
                    noteDuration = getNoteLengthInTicks(graceNotes[j], staff) / divisor;
                    graceNotesDuration += noteDuration;
                    if (graceNotes[j] instanceof Note)
                      playNote(
                          (Note) graceNotes[j], i, currentKey, elapsedTime, noteDuration, track);
                    else
                      playMultiNote(
                          (MultiNote) graceNotes[j],
                          i,
                          currentKey, /*elapsedTime,*/
                          noteDuration,
                          track,
                          staff);
                    elapsedTime += noteDuration;
                  }
                }
                for (int j = 0; j < decorationNotes.size(); j++) {
                  noteDuration = getNoteLengthInTicks((Note) decorationNotes.elementAt(j), staff);
                  graceNotesDuration += noteDuration;
                  playNote(
                      (Note) decorationNotes.elementAt(j),
                      i,
                      currentKey,
                      elapsedTime,
                      noteDuration,
                      track);
                  elapsedTime += noteDuration;
                }
              }
              // The note duration if the note isn't part of a tuplet.
              noteDuration = getNoteLengthInTicks(note, staff) - graceNotesDuration;
              if (noteDuration <= 0) // in case of too much grace notes
              noteDuration = getNoteLengthInTicks(note, staff);
              if (fermata) noteDuration *= 2;
              playNote(note, i, currentKey, elapsedTime, noteDuration, track);
              elapsedTime += noteDuration;
            } else
            // ==================================================================== MULTI NOTE
            if ((voice.elementAt(i) instanceof abc.notation.MultiNote)) {
              MultiNote multiNote = (MultiNote) voice.elementAt(i);
              playMultiNote(multiNote, i, currentKey, elapsedTime, track, staff);
              elapsedTime += getNoteLengthInTicks(multiNote, staff);
            }
          } // endif (!inWrongEnding)
          // ====================================================================== REPEAT BAR LINE
          if (voice.elementAt(i) instanceof abc.notation.RepeatBarLine) {
            RepeatBarLine bar = (RepeatBarLine) voice.elementAt(i);
            if (repeatNumber < bar.getRepeatNumbers()[0] && lastRepeatOpen != -1) {
              repeatNumber++;
              i = lastRepeatOpen;
            } else if (repeatNumber > bar.getRepeatNumbers()[0]) inWrongEnding = true;
            else inWrongEnding = false;
          } else
          // ====================================================================== BAR LINE OPEN /
          // CLOSE
          if (voice.elementAt(i) instanceof abc.notation.BarLine) {
            // currentKey = new KeySignature(tuneKey.getAccidentals());
            switch (((BarLine) (voice.elementAt(i))).getType()) {
              case BarLine.SIMPLE:
                break;
              case BarLine.REPEAT_OPEN:
                lastRepeatOpen = i;
                repeatNumber = 1;
                break;
              case BarLine.REPEAT_CLOSE:
                if (repeatNumber < 2 && lastRepeatOpen != -1) {
                  repeatNumber++;
                  i = lastRepeatOpen;
                } else {
                  repeatNumber = 1;
                  lastRepeatOpen = -1;
                }
                break;
                // TODO case BarLine.BEGIN_AND_END_REPEAT
            }
          }
          // Whatever kind of bar line it is
          if (voice.elementAt(i) instanceof abc.notation.BarLine) {
            currentKey = new KeySignature(tuneKey.getAccidentals());
          }
          i++;
        } // end while each element in voice
      } // end while each voice in music
    } catch (InvalidMidiDataException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return sequence;
  }
Ejemplo n.º 4
0
  // possibly .......,.
  @Deprecated
  protected void setUpKeys() {

    getPlayOptions();

    if (!isDrumLane()) {
      getPlayOptions().drumMapped = false;

    } else {
      if (playOptions.noteMap != null) {
        playOptions.drumMapped = true;
      }
    }
    notifyFocusListeners();

    if (true) {
      return;
    }

    keyNames = null;
    if (!isDrumLane()) {
      playOptions.drumMapped = false;

    } else {
      if (playOptions.noteMap != null) {
        playOptions.drumMapped = true;
      }
      Instrument inst = null;
      MidiDevice dev = getMidiDevice();

      if (dev instanceof SynthRack) {
        Synth syn = ((SynthRack) dev).getSynth(midiChannel);
        if (syn instanceof MySampler) {
          keyNames = new String[128];
          MySampler mys = (MySampler) syn;
          SampledSoundSettings[][] ssss = mys.sampledSounds;

          for (int i = 0; i < 128; i++) {
            if (ssss[i][0] != null) {
              keyNames[i] = ssss[i][0].toString();
            }
          }
        }
      } else if (dev instanceof SynthWrapper) {
        dev = ((SynthWrapper) dev).getRealDevice();
        if (dev instanceof Synthesizer) {
          Synthesizer synth = (Synthesizer) dev;
          //      System.out.println(synth);
          MyPatch patch = getProgram();

          Method getChannels = null;

          //         System.out.println(" LANE PATCH " + patch);
          Instrument insts[] = synth.getLoadedInstruments();
          for (Instrument ins : insts) {
            //        System.out.println(" INST :" + ins);
            Instrument li = (Instrument) ins;

            boolean[] channels = null;
            try {
              if (getChannels != null) {
                if (getChannels.getDeclaringClass() != li.getClass()) {
                  getChannels = null;
                }
              }
              if (getChannels == null) {
                getChannels = li.getClass().getMethod("getChannels");
              }
              if (getChannels != null) {
                channels = (boolean[]) getChannels.invoke(li, (Object[]) null);
              }
            } catch (Exception e) {
            }

            //                         System. out.print(ins.getName() + " "
            //                         + ins.getPatch().getBank() + " "
            //                         + ins.getPatch().getProgram() + " ");
            //                         for (int i = 0; i < li.getChannels().length; i++) {
            //                         if (li.getChannels()[i])
            //                         System. out.print(i + "|");
            //                         }
            //
            //                         System. out.println(li.getChannels());
            if (channels != null) {
              if ((ins.getPatch().getProgram() == patch.prog) && channels[midiChannel]) {
                inst = ins;
                break;
              }
            }
          }

          if (inst == null) {
            insts = synth.getAvailableInstruments();
            for (Instrument ins : insts) {
              Instrument li = (Instrument) ins;

              boolean[] channels = null;
              try {
                if (getChannels != null) {
                  if (getChannels.getDeclaringClass() != li.getClass()) {
                    getChannels = null;
                  }
                }
                if (getChannels == null) {
                  getChannels = li.getClass().getMethod("getChannels");
                }
                if (getChannels != null) {
                  channels = (boolean[]) getChannels.invoke(li, (Object[]) null);
                }
              } catch (Exception e) {
              }
              // System. out.print(ins.getName() + " "
              // + ins.getPatch().getBank() + " "
              // + ins.getPatch().getProgram() + " ");
              // for (int i = 0; i < li.getChannels().length; i++) {
              // if (li.getChannels()[i])
              // System. out.print(i + "|");
              // }
              //
              // System. out.println(li.getChannels());
              if (channels != null) {
                if ((ins.getPatch().getProgram() == patch.prog) && channels[midiChannel]) {
                  inst = ins;
                  break;
                }
              }
            }
          }

          if (inst != null) {
            try {
              Method getKeys = inst.getClass().getMethod("getKeys");
              if (getKeys != null) {
                keyNames = (String[]) getKeys.invoke(inst, (Object[]) null);
              }
            } catch (Exception e) {
            }
          }
        }
      }
    }

    // System. out.println(" Setup keynames " + keyNames);
    notifyFocusListeners();
  }