/*
 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.sun.media.sound;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sound.midi.Patch;

/**
 * Soundfont instrument.
 *
 * @author Karl Helgason
 */
public final class SF2Instrument extends ModelInstrument {

    String name = "";
    int preset = 0;
    int bank = 0;
    long library = 0;
    long genre = 0;
    long morphology = 0;
    SF2GlobalRegion globalregion = null;
    List<SF2InstrumentRegion> regions
            = new ArrayList<SF2InstrumentRegion>();

    public SF2Instrument() {
        super(null, null, null, null);
    }

    public SF2Instrument(SF2Soundbank soundbank) {
        super(soundbank, null, null, null);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Patch getPatch() {
        if (bank == 128)
            return new ModelPatch(0, preset, true);
        else
            return new ModelPatch(bank << 7, preset, false);
    }

    public void setPatch(Patch patch) {
        if (patch instanceof ModelPatch && ((ModelPatch) patch).isPercussion()) {
            bank = 128;
            preset = patch.getProgram();
        } else {
            bank = patch.getBank() >> 7;
            preset = patch.getProgram();
        }
    }

    public Object getData() {
        return null;
    }

    public long getGenre() {
        return genre;
    }

    public void setGenre(long genre) {
        this.genre = genre;
    }

    public long getLibrary() {
        return library;
    }

    public void setLibrary(long library) {
        this.library = library;
    }

    public long getMorphology() {
        return morphology;
    }

    public void setMorphology(long morphology) {
        this.morphology = morphology;
    }

    public List<SF2InstrumentRegion> getRegions() {
        return regions;
    }

    public SF2GlobalRegion getGlobalRegion() {
        return globalregion;
    }

    public void setGlobalZone(SF2GlobalRegion zone) {
        globalregion = zone;
    }

    public String toString() {
        if (bank == 128)
            return "Drumkit: " + name + " preset #" + preset;
        else
            return "Instrument: " + name + " bank #" + bank
                    + " preset #" + preset;
    }

    public ModelPerformer[] getPerformers() {
        int performercount = 0;
        for (SF2InstrumentRegion presetzone : regions)
            performercount += presetzone.getLayer().getRegions().size();
        ModelPerformer[] performers = new ModelPerformer[performercount];
        int pi = 0;

        SF2GlobalRegion presetglobal = globalregion;
        for (SF2InstrumentRegion presetzone : regions) {
            Map<Integer, Short> pgenerators = new HashMap<Integer, Short>();
            pgenerators.putAll(presetzone.getGenerators());
            if (presetglobal != null)
                pgenerators.putAll(presetglobal.getGenerators());

            SF2Layer layer = presetzone.getLayer();
            SF2GlobalRegion layerglobal = layer.getGlobalRegion();
            for (SF2LayerRegion layerzone : layer.getRegions()) {
                ModelPerformer performer = new ModelPerformer();
                if (layerzone.getSample() != null)
                    performer.setName(layerzone.getSample().getName());
                else
                    performer.setName(layer.getName());

                performers[pi++] = performer;

                int keyfrom = 0;
                int keyto = 127;
                int velfrom = 0;
                int velto = 127;

                if (layerzone.contains(SF2Region.GENERATOR_EXCLUSIVECLASS)) {
                    performer.setExclusiveClass(layerzone.getInteger(
                            SF2Region.GENERATOR_EXCLUSIVECLASS));
                }
                if (layerzone.contains(SF2Region.GENERATOR_KEYRANGE)) {
                    byte[] bytes = layerzone.getBytes(
                            SF2Region.GENERATOR_KEYRANGE);
                    if (bytes[0] >= 0)
                        if (bytes[0] > keyfrom)
                            keyfrom = bytes[0];
                    if (bytes[1] >= 0)
                        if (bytes[1] < keyto)
                            keyto = bytes[1];
                }
                if (layerzone.contains(SF2Region.GENERATOR_VELRANGE)) {
                    byte[] bytes = layerzone.getBytes(
                            SF2Region.GENERATOR_VELRANGE);
                    if (bytes[0] >= 0)
                        if (bytes[0] > velfrom)
                            velfrom = bytes[0];
                    if (bytes[1] >= 0)
                        if (bytes[1] < velto)
                            velto = bytes[1];
                }
                if (presetzone.contains(SF2Region.GENERATOR_KEYRANGE)) {
                    byte[] bytes = presetzone.getBytes(
                            SF2Region.GENERATOR_KEYRANGE);
                    if (bytes[0] > keyfrom)
                        keyfrom = bytes[0];
                    if (bytes[1] < keyto)
                        keyto = bytes[1];
                }
                if (presetzone.contains(SF2Region.GENERATOR_VELRANGE)) {
                    byte[] bytes = presetzone.getBytes(
                            SF2Region.GENERATOR_VELRANGE);
                    if (bytes[0] > velfrom)
                        velfrom = bytes[0];
                    if (bytes[1] < velto)
                        velto = bytes[1];
                }
                performer.setKeyFrom(keyfrom);
                performer.setKeyTo(keyto);
                performer.setVelFrom(velfrom);
                performer.setVelTo(velto);

                int startAddrsOffset = layerzone.getShort(
                        SF2Region.GENERATOR_STARTADDRSOFFSET);
                int endAddrsOffset = layerzone.getShort(
                        SF2Region.GENERATOR_ENDADDRSOFFSET);
                int startloopAddrsOffset = layerzone.getShort(
                        SF2Region.GENERATOR_STARTLOOPADDRSOFFSET);
                int endloopAddrsOffset = layerzone.getShort(
                        SF2Region.GENERATOR_ENDLOOPADDRSOFFSET);

                startAddrsOffset += layerzone.getShort(
                        SF2Region.GENERATOR_STARTADDRSCOARSEOFFSET) * 32768;
                endAddrsOffset += layerzone.getShort(
                        SF2Region.GENERATOR_ENDADDRSCOARSEOFFSET) * 32768;
                startloopAddrsOffset += layerzone.getShort(
                        SF2Region.GENERATOR_STARTLOOPADDRSCOARSEOFFSET) * 32768;
                endloopAddrsOffset += layerzone.getShort(
                        SF2Region.GENERATOR_ENDLOOPADDRSCOARSEOFFSET) * 32768;
                startloopAddrsOffset -= startAddrsOffset;
                endloopAddrsOffset -= startAddrsOffset;

                SF2Sample sample = layerzone.getSample();
                int rootkey = sample.originalPitch;
                if (layerzone.getShort(SF2Region.GENERATOR_OVERRIDINGROOTKEY) != -1) {
                    rootkey = layerzone.getShort(
                            SF2Region.GENERATOR_OVERRIDINGROOTKEY);
                }
                float pitchcorrection = (-rootkey * 100) + sample.pitchCorrection;
                ModelByteBuffer buff = sample.getDataBuffer();
                ModelByteBuffer buff24 = sample.getData24Buffer();

                if (startAddrsOffset != 0 || endAddrsOffset != 0) {
                    buff = buff.subbuffer(startAddrsOffset * 2,
                            buff.capacity() + endAddrsOffset * 2);
                    if (buff24 != null) {
                        buff24 = buff24.subbuffer(startAddrsOffset,
                                buff24.capacity() + endAddrsOffset);
                    }

                    /*
                    if (startAddrsOffset < 0)
                        startAddrsOffset = 0;
                    if (endAddrsOffset > (buff.capacity()/2-startAddrsOffset))
                        startAddrsOffset = (int)buff.capacity()/2-startAddrsOffset;
                    byte[] data = buff.array();
                    int off = (int)buff.arrayOffset() + startAddrsOffset*2;
                    int len = (int)buff.capacity() + endAddrsOffset*2;
                    if (off+len > data.length)
                        len = data.length - off;
                    buff = new ModelByteBuffer(data, off, len);
                    if(buff24 != null) {
                        data = buff.array();
                        off = (int)buff.arrayOffset() + startAddrsOffset;
                        len = (int)buff.capacity() + endAddrsOffset;
                        buff24 = new ModelByteBuffer(data, off, len);
                    }
                    */
                }

                ModelByteBufferWavetable osc = new ModelByteBufferWavetable(
                        buff, sample.getFormat(), pitchcorrection);
                if (buff24 != null)
                    osc.set8BitExtensionBuffer(buff24);

                Map<Integer, Short> generators = new HashMap<Integer, Short>();
                if (layerglobal != null)
                    generators.putAll(layerglobal.getGenerators());
                generators.putAll(layerzone.getGenerators());
                for (Map.Entry<Integer, Short> gen : pgenerators.entrySet()) {
                    short val;
                    if (!generators.containsKey(gen.getKey()))
                        val = layerzone.getShort(gen.getKey());
                    else
                        val = generators.get(gen.getKey());
                    val += gen.getValue();
                    generators.put(gen.getKey(), val);
                }

                // SampleMode:
                // 0 indicates a sound reproduced with no loop
                // 1 indicates a sound which loops continuously
                // 2 is unused but should be interpreted as indicating no loop
                // 3 indicates a sound which loops for the duration of key
                //   depression then proceeds to play the remainder of the sample.
                int sampleMode = getGeneratorValue(generators,
                        SF2Region.GENERATOR_SAMPLEMODES);
                if ((sampleMode == 1) || (sampleMode == 3)) {
                    if (sample.startLoop >= 0 && sample.endLoop > 0) {
                        osc.setLoopStart((int)(sample.startLoop
                                + startloopAddrsOffset));
                        osc.setLoopLength((int)(sample.endLoop - sample.startLoop
                                + endloopAddrsOffset - startloopAddrsOffset));
                        if (sampleMode == 1)
                            osc.setLoopType(ModelWavetable.LOOP_TYPE_FORWARD);
                        if (sampleMode == 3)
                            osc.setLoopType(ModelWavetable.LOOP_TYPE_RELEASE);
                    }
                }
                performer.getOscillators().add(osc);


                short volDelay = getGeneratorValue(generators,
                        SF2Region.GENERATOR_DELAYVOLENV);
                short volAttack = getGeneratorValue(generators,
                        SF2Region.GENERATOR_ATTACKVOLENV);
                short volHold = getGeneratorValue(generators,
                        SF2Region.GENERATOR_HOLDVOLENV);
                short volDecay = getGeneratorValue(generators,
                        SF2Region.GENERATOR_DECAYVOLENV);
                short volSustain = getGeneratorValue(generators,
                        SF2Region.GENERATOR_SUSTAINVOLENV);
                short volRelease = getGeneratorValue(generators,
                        SF2Region.GENERATOR_RELEASEVOLENV);

                if (volHold != -12000) {
                    short volKeyNumToHold = getGeneratorValue(generators,
                            SF2Region.GENERATOR_KEYNUMTOVOLENVHOLD);
                    volHold += 60 * volKeyNumToHold;
                    float fvalue = -volKeyNumToHold * 128;
                    ModelIdentifier src = ModelSource.SOURCE_NOTEON_KEYNUMBER;
                    ModelIdentifier dest = ModelDestination.DESTINATION_EG1_HOLD;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(new ModelSource(src), fvalue,
                            new ModelDestination(dest)));
                }
                if (volDecay != -12000) {
                    short volKeyNumToDecay = getGeneratorValue(generators,
                            SF2Region.GENERATOR_KEYNUMTOVOLENVDECAY);
                    volDecay += 60 * volKeyNumToDecay;
                    float fvalue = -volKeyNumToDecay * 128;
                    ModelIdentifier src = ModelSource.SOURCE_NOTEON_KEYNUMBER;
                    ModelIdentifier dest = ModelDestination.DESTINATION_EG1_DECAY;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(new ModelSource(src), fvalue,
                            new ModelDestination(dest)));
                }

                addTimecentValue(performer,
                        ModelDestination.DESTINATION_EG1_DELAY, volDelay);
                addTimecentValue(performer,
                        ModelDestination.DESTINATION_EG1_ATTACK, volAttack);
                addTimecentValue(performer,
                        ModelDestination.DESTINATION_EG1_HOLD, volHold);
                addTimecentValue(performer,
                        ModelDestination.DESTINATION_EG1_DECAY, volDecay);
                //float fvolsustain = (960-volSustain)*(1000.0f/960.0f);

                volSustain = (short)(1000 - volSustain);
                if (volSustain < 0)
                    volSustain = 0;
                if (volSustain > 1000)
                    volSustain = 1000;

                addValue(performer,
                        ModelDestination.DESTINATION_EG1_SUSTAIN, volSustain);
                addTimecentValue(performer,
                        ModelDestination.DESTINATION_EG1_RELEASE, volRelease);

                if (getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODENVTOFILTERFC) != 0
                        || getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODENVTOPITCH) != 0) {
                    short modDelay = getGeneratorValue(generators,
                            SF2Region.GENERATOR_DELAYMODENV);
                    short modAttack = getGeneratorValue(generators,
                            SF2Region.GENERATOR_ATTACKMODENV);
                    short modHold = getGeneratorValue(generators,
                            SF2Region.GENERATOR_HOLDMODENV);
                    short modDecay = getGeneratorValue(generators,
                            SF2Region.GENERATOR_DECAYMODENV);
                    short modSustain = getGeneratorValue(generators,
                            SF2Region.GENERATOR_SUSTAINMODENV);
                    short modRelease = getGeneratorValue(generators,
                            SF2Region.GENERATOR_RELEASEMODENV);


                    if (modHold != -12000) {
                        short modKeyNumToHold = getGeneratorValue(generators,
                                SF2Region.GENERATOR_KEYNUMTOMODENVHOLD);
                        modHold += 60 * modKeyNumToHold;
                        float fvalue = -modKeyNumToHold * 128;
                        ModelIdentifier src = ModelSource.SOURCE_NOTEON_KEYNUMBER;
                        ModelIdentifier dest = ModelDestination.DESTINATION_EG2_HOLD;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(new ModelSource(src),
                                fvalue, new ModelDestination(dest)));
                    }
                    if (modDecay != -12000) {
                        short modKeyNumToDecay = getGeneratorValue(generators,
                                SF2Region.GENERATOR_KEYNUMTOMODENVDECAY);
                        modDecay += 60 * modKeyNumToDecay;
                        float fvalue = -modKeyNumToDecay * 128;
                        ModelIdentifier src = ModelSource.SOURCE_NOTEON_KEYNUMBER;
                        ModelIdentifier dest = ModelDestination.DESTINATION_EG2_DECAY;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(new ModelSource(src),
                                fvalue, new ModelDestination(dest)));
                    }

                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_EG2_DELAY, modDelay);
                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_EG2_ATTACK, modAttack);
                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_EG2_HOLD, modHold);
                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_EG2_DECAY, modDecay);
                    if (modSustain < 0)
                        modSustain = 0;
                    if (modSustain > 1000)
                        modSustain = 1000;
                    addValue(performer, ModelDestination.DESTINATION_EG2_SUSTAIN,
                            1000 - modSustain);
                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_EG2_RELEASE, modRelease);

                    if (getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODENVTOFILTERFC) != 0) {
                        double fvalue = getGeneratorValue(generators,
                                SF2Region.GENERATOR_MODENVTOFILTERFC);
                        ModelIdentifier src = ModelSource.SOURCE_EG2;
                        ModelIdentifier dest
                                = ModelDestination.DESTINATION_FILTER_FREQ;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(new ModelSource(src),
                                fvalue, new ModelDestination(dest)));
                    }

                    if (getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODENVTOPITCH) != 0) {
                        double fvalue = getGeneratorValue(generators,
                                SF2Region.GENERATOR_MODENVTOPITCH);
                        ModelIdentifier src = ModelSource.SOURCE_EG2;
                        ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(new ModelSource(src),
                                fvalue, new ModelDestination(dest)));
                    }

                }

                if (getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOFILTERFC) != 0
                        || getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOPITCH) != 0
                        || getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOVOLUME) != 0) {
                    short lfo_freq = getGeneratorValue(generators,
                            SF2Region.GENERATOR_FREQMODLFO);
                    short lfo_delay = getGeneratorValue(generators,
                            SF2Region.GENERATOR_DELAYMODLFO);
                    addTimecentValue(performer,
                            ModelDestination.DESTINATION_LFO1_DELAY, lfo_delay);
                    addValue(performer,
                            ModelDestination.DESTINATION_LFO1_FREQ, lfo_freq);
                }

                short vib_freq = getGeneratorValue(generators,
                        SF2Region.GENERATOR_FREQVIBLFO);
                short vib_delay = getGeneratorValue(generators,
                        SF2Region.GENERATOR_DELAYVIBLFO);
                addTimecentValue(performer,
                        ModelDestination.DESTINATION_LFO2_DELAY, vib_delay);
                addValue(performer,
                        ModelDestination.DESTINATION_LFO2_FREQ, vib_freq);


                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_VIBLFOTOPITCH) != 0) {
                    double fvalue = getGeneratorValue(generators,
                            SF2Region.GENERATOR_VIBLFOTOPITCH);
                    ModelIdentifier src = ModelSource.SOURCE_LFO2;
                    ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(
                            new ModelSource(src,
                                ModelStandardTransform.DIRECTION_MIN2MAX,
                                ModelStandardTransform.POLARITY_BIPOLAR),
                            fvalue, new ModelDestination(dest)));
                }

                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_MODLFOTOFILTERFC) != 0) {
                    double fvalue = getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOFILTERFC);
                    ModelIdentifier src = ModelSource.SOURCE_LFO1;
                    ModelIdentifier dest = ModelDestination.DESTINATION_FILTER_FREQ;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(
                            new ModelSource(src,
                                ModelStandardTransform.DIRECTION_MIN2MAX,
                                ModelStandardTransform.POLARITY_BIPOLAR),
                            fvalue, new ModelDestination(dest)));
                }

                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_MODLFOTOPITCH) != 0) {
                    double fvalue = getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOPITCH);
                    ModelIdentifier src = ModelSource.SOURCE_LFO1;
                    ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(
                            new ModelSource(src,
                                ModelStandardTransform.DIRECTION_MIN2MAX,
                                ModelStandardTransform.POLARITY_BIPOLAR),
                            fvalue, new ModelDestination(dest)));
                }

                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_MODLFOTOVOLUME) != 0) {
                    double fvalue = getGeneratorValue(generators,
                            SF2Region.GENERATOR_MODLFOTOVOLUME);
                    ModelIdentifier src = ModelSource.SOURCE_LFO1;
                    ModelIdentifier dest = ModelDestination.DESTINATION_GAIN;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(
                            new ModelSource(src,
                                ModelStandardTransform.DIRECTION_MIN2MAX,
                                ModelStandardTransform.POLARITY_BIPOLAR),
                            fvalue, new ModelDestination(dest)));
                }

                if (layerzone.getShort(SF2Region.GENERATOR_KEYNUM) != -1) {
                    double val = layerzone.getShort(SF2Region.GENERATOR_KEYNUM)/128.0;
                    addValue(performer, ModelDestination.DESTINATION_KEYNUMBER, val);
                }

                if (layerzone.getShort(SF2Region.GENERATOR_VELOCITY) != -1) {
                    double val = layerzone.getShort(SF2Region.GENERATOR_VELOCITY)
                                 / 128.0;
                    addValue(performer, ModelDestination.DESTINATION_VELOCITY, val);
                }

                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_INITIALFILTERFC) < 13500) {
                    short filter_freq = getGeneratorValue(generators,
                            SF2Region.GENERATOR_INITIALFILTERFC);
                    short filter_q = getGeneratorValue(generators,
                            SF2Region.GENERATOR_INITIALFILTERQ);
                    addValue(performer,
                            ModelDestination.DESTINATION_FILTER_FREQ, filter_freq);
                    addValue(performer,
                            ModelDestination.DESTINATION_FILTER_Q, filter_q);
                }

                int tune = 100 * getGeneratorValue(generators,
                        SF2Region.GENERATOR_COARSETUNE);
                tune += getGeneratorValue(generators,
                        SF2Region.GENERATOR_FINETUNE);
                if (tune != 0) {
                    addValue(performer,
                            ModelDestination.DESTINATION_PITCH, (short) tune);
                }
                if (getGeneratorValue(generators, SF2Region.GENERATOR_PAN) != 0) {
                    short val = getGeneratorValue(generators,
                            SF2Region.GENERATOR_PAN);
                    addValue(performer, ModelDestination.DESTINATION_PAN, val);
                }
                if (getGeneratorValue(generators, SF2Region.GENERATOR_INITIALATTENUATION) != 0) {
                    short val = getGeneratorValue(generators,
                            SF2Region.GENERATOR_INITIALATTENUATION);
                    addValue(performer,
                            ModelDestination.DESTINATION_GAIN, -0.376287f * val);
                }
                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_CHORUSEFFECTSSEND) != 0) {
                    short val = getGeneratorValue(generators,
                            SF2Region.GENERATOR_CHORUSEFFECTSSEND);
                    addValue(performer, ModelDestination.DESTINATION_CHORUS, val);
                }
                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_REVERBEFFECTSSEND) != 0) {
                    short val = getGeneratorValue(generators,
                            SF2Region.GENERATOR_REVERBEFFECTSSEND);
                    addValue(performer, ModelDestination.DESTINATION_REVERB, val);
                }
                if (getGeneratorValue(generators,
                        SF2Region.GENERATOR_SCALETUNING) != 100) {
                    short fvalue = getGeneratorValue(generators,
                            SF2Region.GENERATOR_SCALETUNING);
                    if (fvalue == 0) {
                        ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(null, rootkey * 100,
                                new ModelDestination(dest)));
                    } else {
                        ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                        performer.getConnectionBlocks().add(
                            new ModelConnectionBlock(null, rootkey * (100 - fvalue),
                                new ModelDestination(dest)));
                    }

                    ModelIdentifier src = ModelSource.SOURCE_NOTEON_KEYNUMBER;
                    ModelIdentifier dest = ModelDestination.DESTINATION_PITCH;
                    performer.getConnectionBlocks().add(
                        new ModelConnectionBlock(new ModelSource(src),
                            128 * fvalue, new ModelDestination(dest)));

                }

                performer.getConnectionBlocks().add(
                    new ModelConnectionBlock(
                        new ModelSource(ModelSource.SOURCE_NOTEON_VELOCITY,
                            new ModelTransform() {
                                public double transform(double value) {
                                    if (value < 0.5)
                                        return 1 - value * 2;
                                    else
                                        return 0;
                                }
                            }),
                        -2400,
                        new ModelDestination(
                            ModelDestination.DESTINATION_FILTER_FREQ)));


                performer.getConnectionBlocks().add(
                    new ModelConnectionBlock(
                        new ModelSource(ModelSource.SOURCE_LFO2,
                            ModelStandardTransform.DIRECTION_MIN2MAX,
                            ModelStandardTransform.POLARITY_BIPOLAR,
                            ModelStandardTransform.TRANSFORM_LINEAR),
                        new ModelSource(new ModelIdentifier("midi_cc", "1", 0),
                            ModelStandardTransform.DIRECTION_MIN2MAX,
                            ModelStandardTransform.POLARITY_UNIPOLAR,
                            ModelStandardTransform.TRANSFORM_LINEAR),
                        50, new ModelDestination(
                            ModelDestination.DESTINATION_PITCH)));

                if (layer.getGlobalRegion() != null) {
                    for (SF2Modulator modulator
                            : layer.getGlobalRegion().getModulators()) {
                        convertModulator(performer, modulator);
                    }
                }
                for (SF2Modulator modulator : layerzone.getModulators())
                    convertModulator(performer, modulator);

                if (presetglobal != null) {
                    for (SF2Modulator modulator : presetglobal.getModulators())
                        convertModulator(performer, modulator);
                }
                for (SF2Modulator modulator : presetzone.getModulators())
                    convertModulator(performer, modulator);

            }
        }
        return performers;
    }

    private void convertModulator(ModelPerformer performer,
            SF2Modulator modulator) {
        ModelSource src1 = convertSource(modulator.getSourceOperator());
        ModelSource src2 = convertSource(modulator.getAmountSourceOperator());
        if (src1 == null && modulator.getSourceOperator() != 0)
            return;
        if (src2 == null && modulator.getAmountSourceOperator() != 0)
            return;
        double amount = modulator.getAmount();
        double[] amountcorrection = new double[1];
        ModelSource[] extrasrc = new ModelSource[1];
        amountcorrection[0] = 1;
        ModelDestination dst = convertDestination(
                modulator.getDestinationOperator(), amountcorrection, extrasrc);
        amount *= amountcorrection[0];
        if (dst == null)
            return;
        if (modulator.getTransportOperator() == SF2Modulator.TRANSFORM_ABSOLUTE) {
            ((ModelStandardTransform)dst.getTransform()).setTransform(
                    ModelStandardTransform.TRANSFORM_ABSOLUTE);
        }
        ModelConnectionBlock conn = new ModelConnectionBlock(src1, src2, amount, dst);
        if (extrasrc[0] != null)
            conn.addSource(extrasrc[0]);
        performer.getConnectionBlocks().add(conn);

    }

    private static ModelSource convertSource(int src) {
        if (src == 0)
            return null;
        ModelIdentifier id = null;
        int idsrc = src & 0x7F;
        if ((src & SF2Modulator.SOURCE_MIDI_CONTROL) != 0) {
            id = new ModelIdentifier("midi_cc", Integer.toString(idsrc));
        } else {
            if (idsrc == SF2Modulator.SOURCE_NOTE_ON_VELOCITY)
                id = ModelSource.SOURCE_NOTEON_VELOCITY;
            if (idsrc == SF2Modulator.SOURCE_NOTE_ON_KEYNUMBER)
                id = ModelSource.SOURCE_NOTEON_KEYNUMBER;
            if (idsrc == SF2Modulator.SOURCE_POLY_PRESSURE)
                id = ModelSource.SOURCE_MIDI_POLY_PRESSURE;
            if (idsrc == SF2Modulator.SOURCE_CHANNEL_PRESSURE)
                id = ModelSource.SOURCE_MIDI_CHANNEL_PRESSURE;
            if (idsrc == SF2Modulator.SOURCE_PITCH_WHEEL)
                id = ModelSource.SOURCE_MIDI_PITCH;
            if (idsrc == SF2Modulator.SOURCE_PITCH_SENSITIVITY)
                id = new ModelIdentifier("midi_rpn", "0");
        }
        if (id == null)
            return null;

        ModelSource msrc = new ModelSource(id);
        ModelStandardTransform transform
                = (ModelStandardTransform) msrc.getTransform();

        if ((SF2Modulator.SOURCE_DIRECTION_MAX_MIN & src) != 0)
            transform.setDirection(ModelStandardTransform.DIRECTION_MAX2MIN);
        else
            transform.setDirection(ModelStandardTransform.DIRECTION_MIN2MAX);

        if ((SF2Modulator.SOURCE_POLARITY_BIPOLAR & src) != 0)
            transform.setPolarity(ModelStandardTransform.POLARITY_BIPOLAR);
        else
            transform.setPolarity(ModelStandardTransform.POLARITY_UNIPOLAR);

        if ((SF2Modulator.SOURCE_TYPE_CONCAVE & src) != 0)
            transform.setTransform(ModelStandardTransform.TRANSFORM_CONCAVE);
        if ((SF2Modulator.SOURCE_TYPE_CONVEX & src) != 0)
            transform.setTransform(ModelStandardTransform.TRANSFORM_CONVEX);
        if ((SF2Modulator.SOURCE_TYPE_SWITCH & src) != 0)
            transform.setTransform(ModelStandardTransform.TRANSFORM_SWITCH);

        return msrc;
    }

    static ModelDestination convertDestination(int dst,
            double[] amountcorrection, ModelSource[] extrasrc) {
        ModelIdentifier id = null;
        switch (dst) {
            case SF2Region.GENERATOR_INITIALFILTERFC:
                id = ModelDestination.DESTINATION_FILTER_FREQ;
                break;
            case SF2Region.GENERATOR_INITIALFILTERQ:
                id = ModelDestination.DESTINATION_FILTER_Q;
                break;
            case SF2Region.GENERATOR_CHORUSEFFECTSSEND:
                id = ModelDestination.DESTINATION_CHORUS;
                break;
            case SF2Region.GENERATOR_REVERBEFFECTSSEND:
                id = ModelDestination.DESTINATION_REVERB;
                break;
            case SF2Region.GENERATOR_PAN:
                id = ModelDestination.DESTINATION_PAN;
                break;
            case SF2Region.GENERATOR_DELAYMODLFO:
                id = ModelDestination.DESTINATION_LFO1_DELAY;
                break;
            case SF2Region.GENERATOR_FREQMODLFO:
                id = ModelDestination.DESTINATION_LFO1_FREQ;
                break;
            case SF2Region.GENERATOR_DELAYVIBLFO:
                id = ModelDestination.DESTINATION_LFO2_DELAY;
                break;
            case SF2Region.GENERATOR_FREQVIBLFO:
                id = ModelDestination.DESTINATION_LFO2_FREQ;
                break;

            case SF2Region.GENERATOR_DELAYMODENV:
                id = ModelDestination.DESTINATION_EG2_DELAY;
                break;
            case SF2Region.GENERATOR_ATTACKMODENV:
                id = ModelDestination.DESTINATION_EG2_ATTACK;
                break;
            case SF2Region.GENERATOR_HOLDMODENV:
                id = ModelDestination.DESTINATION_EG2_HOLD;
                break;
            case SF2Region.GENERATOR_DECAYMODENV:
                id = ModelDestination.DESTINATION_EG2_DECAY;
                break;
            case SF2Region.GENERATOR_SUSTAINMODENV:
                id = ModelDestination.DESTINATION_EG2_SUSTAIN;
                amountcorrection[0] = -1;
                break;
            case SF2Region.GENERATOR_RELEASEMODENV:
                id = ModelDestination.DESTINATION_EG2_RELEASE;
                break;
            case SF2Region.GENERATOR_DELAYVOLENV:
                id = ModelDestination.DESTINATION_EG1_DELAY;
                break;
            case SF2Region.GENERATOR_ATTACKVOLENV:
                id = ModelDestination.DESTINATION_EG1_ATTACK;
                break;
            case SF2Region.GENERATOR_HOLDVOLENV:
                id = ModelDestination.DESTINATION_EG1_HOLD;
                break;
            case SF2Region.GENERATOR_DECAYVOLENV:
                id = ModelDestination.DESTINATION_EG1_DECAY;
                break;
            case SF2Region.GENERATOR_SUSTAINVOLENV:
                id = ModelDestination.DESTINATION_EG1_SUSTAIN;
                amountcorrection[0] = -1;
                break;
            case SF2Region.GENERATOR_RELEASEVOLENV:
                id = ModelDestination.DESTINATION_EG1_RELEASE;
                break;
            case SF2Region.GENERATOR_KEYNUM:
                id = ModelDestination.DESTINATION_KEYNUMBER;
                break;
            case SF2Region.GENERATOR_VELOCITY:
                id = ModelDestination.DESTINATION_VELOCITY;
                break;

            case SF2Region.GENERATOR_COARSETUNE:
                amountcorrection[0] = 100;
                id = ModelDestination.DESTINATION_PITCH;
                break;

            case SF2Region.GENERATOR_FINETUNE:
                id = ModelDestination.DESTINATION_PITCH;
                break;

            case SF2Region.GENERATOR_INITIALATTENUATION:
                id = ModelDestination.DESTINATION_GAIN;
                amountcorrection[0] = -0.376287f;
                break;

            case SF2Region.GENERATOR_VIBLFOTOPITCH:
                id = ModelDestination.DESTINATION_PITCH;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_LFO2,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            case SF2Region.GENERATOR_MODLFOTOPITCH:
                id = ModelDestination.DESTINATION_PITCH;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_LFO1,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            case SF2Region.GENERATOR_MODLFOTOFILTERFC:
                id = ModelDestination.DESTINATION_FILTER_FREQ;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_LFO1,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            case SF2Region.GENERATOR_MODLFOTOVOLUME:
                id = ModelDestination.DESTINATION_GAIN;
                amountcorrection[0] = -0.376287f;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_LFO1,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            case SF2Region.GENERATOR_MODENVTOPITCH:
                id = ModelDestination.DESTINATION_PITCH;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_EG2,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            case SF2Region.GENERATOR_MODENVTOFILTERFC:
                id = ModelDestination.DESTINATION_FILTER_FREQ;
                extrasrc[0] = new ModelSource(
                        ModelSource.SOURCE_EG2,
                        ModelStandardTransform.DIRECTION_MIN2MAX,
                        ModelStandardTransform.POLARITY_BIPOLAR);
                break;

            default:
                break;
        }
        if (id != null)
            return new ModelDestination(id);
        return null;
    }

    private void addTimecentValue(ModelPerformer performer,
            ModelIdentifier dest, short value) {
        double fvalue;
        if (value == -12000)
            fvalue = Double.NEGATIVE_INFINITY;
        else
            fvalue = value;
        performer.getConnectionBlocks().add(
                new ModelConnectionBlock(fvalue, new ModelDestination(dest)));
    }

    private void addValue(ModelPerformer performer,
            ModelIdentifier dest, short value) {
        double fvalue = value;
        performer.getConnectionBlocks().add(
                new ModelConnectionBlock(fvalue, new ModelDestination(dest)));
    }

    private void addValue(ModelPerformer performer,
            ModelIdentifier dest, double value) {
        double fvalue = value;
        performer.getConnectionBlocks().add(
                new ModelConnectionBlock(fvalue, new ModelDestination(dest)));
    }

    private short getGeneratorValue(Map<Integer, Short> generators, int gen) {
        if (generators.containsKey(gen))
            return generators.get(gen);
        return SF2Region.getDefaultValue(gen);
    }
}
