/*
 * 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.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

This class decodes information from ModelPeformer for use in SoftVoice.
It also adds default connections if they where missing in ModelPerformer.
Author:
Karl Helgason/**
 * This class decodes information from ModelPeformer for use in SoftVoice.
 * It also adds default connections if they where missing in ModelPerformer.
 *
 * @author Karl Helgason
 */
public final class SoftPerformer {

    static ModelConnectionBlock[] defaultconnections
            = new ModelConnectionBlock[42];

    static {
        int o = 0;
        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("noteon", "on", 0),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1, new ModelDestination(new ModelIdentifier("eg", "on", 0)));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("noteon", "on", 0),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1, new ModelDestination(new ModelIdentifier("eg", "on", 1)));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("eg", "active", 0),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1, new ModelDestination(new ModelIdentifier("mixer", "active", 0)));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("eg", 0),
                ModelStandardTransform.DIRECTION_MAX2MIN,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            -960, new ModelDestination(new ModelIdentifier("mixer", "gain")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("noteon", "velocity"),
                ModelStandardTransform.DIRECTION_MAX2MIN,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_CONCAVE),
            -960, new ModelDestination(new ModelIdentifier("mixer", "gain")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi", "pitch"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            new ModelSource(new ModelIdentifier("midi_rpn", "0"),
                new ModelTransform() {
                    public double transform(double value) {
                        int v = (int) (value * 16384.0);
                        int msb = v >> 7;
                        int lsb = v & 127;
                        return msb * 100 + lsb;
                    }
                }),
            new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("noteon", "keynumber"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            12800, new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "7"),
                ModelStandardTransform.DIRECTION_MAX2MIN,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_CONCAVE),
            -960, new ModelDestination(new ModelIdentifier("mixer", "gain")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "8"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1000, new ModelDestination(new ModelIdentifier("mixer", "balance")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "10"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1000, new ModelDestination(new ModelIdentifier("mixer", "pan")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "11"),
                ModelStandardTransform.DIRECTION_MAX2MIN,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_CONCAVE),
            -960, new ModelDestination(new ModelIdentifier("mixer", "gain")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "91"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1000, new ModelDestination(new ModelIdentifier("mixer", "reverb")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "93"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            1000, new ModelDestination(new ModelIdentifier("mixer", "chorus")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "71"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            200, new ModelDestination(new ModelIdentifier("filter", "q")));
        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "74"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            9600, new ModelDestination(new ModelIdentifier("filter", "freq")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "72"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            6000, new ModelDestination(new ModelIdentifier("eg", "release2")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "73"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            2000, new ModelDestination(new ModelIdentifier("eg", "attack2")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "75"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            6000, new ModelDestination(new ModelIdentifier("eg", "decay2")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "67"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_SWITCH),
            -50, new ModelDestination(ModelDestination.DESTINATION_GAIN));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_cc", "67"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_UNIPOLAR,
                ModelStandardTransform.TRANSFORM_SWITCH),
            -2400, new ModelDestination(ModelDestination.DESTINATION_FILTER_FREQ));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_rpn", "1"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            100, new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("midi_rpn", "2"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            12800, new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("master", "fine_tuning"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            100, new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(
            new ModelSource(
                new ModelIdentifier("master", "coarse_tuning"),
                ModelStandardTransform.DIRECTION_MIN2MAX,
                ModelStandardTransform.POLARITY_BIPOLAR,
                ModelStandardTransform.TRANSFORM_LINEAR),
            12800, new ModelDestination(new ModelIdentifier("osc", "pitch")));

        defaultconnections[o++] = new ModelConnectionBlock(13500,
                new ModelDestination(new ModelIdentifier("filter", "freq", 0)));

        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "delay", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "attack", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "hold", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "decay", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(1000,
                new ModelDestination(new ModelIdentifier("eg", "sustain", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "release", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(1200.0
                * Math.log(0.015) / Math.log(2), new ModelDestination(
                new ModelIdentifier("eg", "shutdown", 0))); // 15 msec default

        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "delay", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "attack", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "hold", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "decay", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(1000,
                new ModelDestination(new ModelIdentifier("eg", "sustain", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("eg", "release", 1)));

        defaultconnections[o++] = new ModelConnectionBlock(-8.51318,
                new ModelDestination(new ModelIdentifier("lfo", "freq", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("lfo", "delay", 0)));
        defaultconnections[o++] = new ModelConnectionBlock(-8.51318,
                new ModelDestination(new ModelIdentifier("lfo", "freq", 1)));
        defaultconnections[o++] = new ModelConnectionBlock(
                Float.NEGATIVE_INFINITY, new ModelDestination(
                new ModelIdentifier("lfo", "delay", 1)));

    }
    public int keyFrom = 0;
    public int keyTo = 127;
    public int velFrom = 0;
    public int velTo = 127;
    public int exclusiveClass = 0;
    public boolean selfNonExclusive = false;
    public boolean forcedVelocity = false;
    public boolean forcedKeynumber = false;
    public ModelPerformer performer;
    public ModelConnectionBlock[] connections;
    public ModelOscillator[] oscillators;
    public Map<Integer, int[]> midi_rpn_connections = new HashMap<Integer, int[]>();
    public Map<Integer, int[]> midi_nrpn_connections = new HashMap<Integer, int[]>();
    public int[][] midi_ctrl_connections;
    public int[][] midi_connections;
    public int[] ctrl_connections;
    private List<Integer> ctrl_connections_list = new ArrayList<Integer>();

    private static class KeySortComparator implements Comparator<ModelSource> {

        public int compare(ModelSource o1, ModelSource o2) {
            return o1.getIdentifier().toString().compareTo(
                    o2.getIdentifier().toString());
        }
    }
    private static KeySortComparator keySortComparator = new KeySortComparator();

    private String extractKeys(ModelConnectionBlock conn) {
        StringBuffer sb = new StringBuffer();
        if (conn.getSources() != null) {
            sb.append("[");
            ModelSource[] srcs = conn.getSources();
            ModelSource[] srcs2 = new ModelSource[srcs.length];
            for (int i = 0; i < srcs.length; i++)
                srcs2[i] = srcs[i];
            Arrays.sort(srcs2, keySortComparator);
            for (int i = 0; i < srcs.length; i++) {
                sb.append(srcs[i].getIdentifier());
                sb.append(";");
            }
            sb.append("]");
        }
        sb.append(";");
        if (conn.getDestination() != null) {
            sb.append(conn.getDestination().getIdentifier());
        }
        sb.append(";");
        return sb.toString();
    }

    private void processSource(ModelSource src, int ix) {
        ModelIdentifier id = src.getIdentifier();
        String o = id.getObject();
        if (o.equals("midi_cc"))
            processMidiControlSource(src, ix);
        else if (o.equals("midi_rpn"))
            processMidiRpnSource(src, ix);
        else if (o.equals("midi_nrpn"))
            processMidiNrpnSource(src, ix);
        else if (o.equals("midi"))
            processMidiSource(src, ix);
        else if (o.equals("noteon"))
            processNoteOnSource(src, ix);
        else if (o.equals("osc"))
            return;
        else if (o.equals("mixer"))
            return;
        else
            ctrl_connections_list.add(ix);
    }

    private void processMidiControlSource(ModelSource src, int ix) {
        String v = src.getIdentifier().getVariable();
        if (v == null)
            return;
        int c = Integer.parseInt(v);
        if (midi_ctrl_connections[c] == null)
            midi_ctrl_connections[c] = new int[]{ix};
        else {
            int[] olda = midi_ctrl_connections[c];
            int[] newa = new int[olda.length + 1];
            for (int i = 0; i < olda.length; i++)
                newa[i] = olda[i];
            newa[newa.length - 1] = ix;
            midi_ctrl_connections[c] = newa;
        }
    }

    private void processNoteOnSource(ModelSource src, int ix) {
        String v = src.getIdentifier().getVariable();
        int c = -1;
        if (v.equals("on"))
            c = 3;
        if (v.equals("keynumber"))
            c = 4;
        if (c == -1)
            return;
        if (midi_connections[c] == null)
            midi_connections[c] = new int[]{ix};
        else {
            int[] olda = midi_connections[c];
            int[] newa = new int[olda.length + 1];
            for (int i = 0; i < olda.length; i++)
                newa[i] = olda[i];
            newa[newa.length - 1] = ix;
            midi_connections[c] = newa;
        }
    }

    private void processMidiSource(ModelSource src, int ix) {
        String v = src.getIdentifier().getVariable();
        int c = -1;
        if (v.equals("pitch"))
            c = 0;
        if (v.equals("channel_pressure"))
            c = 1;
        if (v.equals("poly_pressure"))
            c = 2;
        if (c == -1)
            return;
        if (midi_connections[c] == null)
            midi_connections[c] = new int[]{ix};
        else {
            int[] olda = midi_connections[c];
            int[] newa = new int[olda.length + 1];
            for (int i = 0; i < olda.length; i++)
                newa[i] = olda[i];
            newa[newa.length - 1] = ix;
            midi_connections[c] = newa;
        }
    }

    private void processMidiRpnSource(ModelSource src, int ix) {
        String v = src.getIdentifier().getVariable();
        if (v == null)
            return;
        int c = Integer.parseInt(v);
        if (midi_rpn_connections.get(c) == null)
            midi_rpn_connections.put(c, new int[]{ix});
        else {
            int[] olda = midi_rpn_connections.get(c);
            int[] newa = new int[olda.length + 1];
            for (int i = 0; i < olda.length; i++)
                newa[i] = olda[i];
            newa[newa.length - 1] = ix;
            midi_rpn_connections.put(c, newa);
        }
    }

    private void processMidiNrpnSource(ModelSource src, int ix) {
        String v = src.getIdentifier().getVariable();
        if (v == null)
            return;
        int c = Integer.parseInt(v);
        if (midi_nrpn_connections.get(c) == null)
            midi_nrpn_connections.put(c, new int[]{ix});
        else {
            int[] olda = midi_nrpn_connections.get(c);
            int[] newa = new int[olda.length + 1];
            for (int i = 0; i < olda.length; i++)
                newa[i] = olda[i];
            newa[newa.length - 1] = ix;
            midi_nrpn_connections.put(c, newa);
        }
    }

    public SoftPerformer(ModelPerformer performer) {
        this.performer = performer;

        keyFrom = performer.getKeyFrom();
        keyTo = performer.getKeyTo();
        velFrom = performer.getVelFrom();
        velTo = performer.getVelTo();
        exclusiveClass = performer.getExclusiveClass();
        selfNonExclusive = performer.isSelfNonExclusive();

        Map<String, ModelConnectionBlock> connmap = new HashMap<String, ModelConnectionBlock>();

        List<ModelConnectionBlock> performer_connections = new ArrayList<ModelConnectionBlock>();
        performer_connections.addAll(performer.getConnectionBlocks());

        if (performer.isDefaultConnectionsEnabled()) {

            // Add modulation depth range (RPN 5) to the modulation wheel (cc#1)

            boolean isModulationWheelConectionFound = false;
            for (int j = 0; j < performer_connections.size(); j++) {
                ModelConnectionBlock connection = performer_connections.get(j);
                ModelSource[] sources = connection.getSources();
                ModelDestination dest = connection.getDestination();
                boolean isModulationWheelConection = false;
                if (dest != null && sources != null && sources.length > 1) {
                    for (int i = 0; i < sources.length; i++) {
                        // check if connection block has the source "modulation
                        // wheel cc#1"
                        if (sources[i].getIdentifier().getObject().equals(
                                "midi_cc")) {
                            if (sources[i].getIdentifier().getVariable()
                                    .equals("1")) {
                                isModulationWheelConection = true;
                                isModulationWheelConectionFound = true;
                                break;
                            }
                        }
                    }
                }
                if (isModulationWheelConection) {

                    ModelConnectionBlock newconnection = new ModelConnectionBlock();
                    newconnection.setSources(connection.getSources());
                    newconnection.setDestination(connection.getDestination());
                    newconnection.addSource(new ModelSource(
                            new ModelIdentifier("midi_rpn", "5")));
                    newconnection.setScale(connection.getScale() * 256.0);
                    performer_connections.set(j, newconnection);
                }
            }

            if (!isModulationWheelConectionFound) {
                ModelConnectionBlock conn = new ModelConnectionBlock(
                        new ModelSource(ModelSource.SOURCE_LFO1,
                        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));
                conn.addSource(new ModelSource(new ModelIdentifier("midi_rpn",
                        "5")));
                conn.setScale(conn.getScale() * 256.0);
                performer_connections.add(conn);

            }

            // Let Aftertouch to behave just like modulation wheel (cc#1)
            boolean channel_pressure_set = false;
            boolean poly_pressure = false;
            ModelConnectionBlock mod_cc_1_connection = null;
            int mod_cc_1_connection_src_ix = 0;

            for (ModelConnectionBlock connection : performer_connections) {
                ModelSource[] sources = connection.getSources();
                ModelDestination dest = connection.getDestination();
                // if(dest != null && sources != null)
                if (dest != null && sources != null) {
                    for (int i = 0; i < sources.length; i++) {
                        ModelIdentifier srcid = sources[i].getIdentifier();
                        // check if connection block has the source "modulation
                        // wheel cc#1"
                        if (srcid.getObject().equals("midi_cc")) {
                            if (srcid.getVariable().equals("1")) {
                                mod_cc_1_connection = connection;
                                mod_cc_1_connection_src_ix = i;
                            }
                        }
                        // check if channel or poly pressure are already
                        // connected
                        if (srcid.getObject().equals("midi")) {
                            if (srcid.getVariable().equals("channel_pressure"))
                                channel_pressure_set = true;
                            if (srcid.getVariable().equals("poly_pressure"))
                                poly_pressure = true;
                        }
                    }
                }

            }

            if (mod_cc_1_connection != null) {
                if (!channel_pressure_set) {
                    ModelConnectionBlock mc = new ModelConnectionBlock();
                    mc.setDestination(mod_cc_1_connection.getDestination());
                    mc.setScale(mod_cc_1_connection.getScale());
                    ModelSource[] src_list = mod_cc_1_connection.getSources();
                    ModelSource[] src_list_new = new ModelSource[src_list.length];
                    for (int i = 0; i < src_list_new.length; i++)
                        src_list_new[i] = src_list[i];
                    src_list_new[mod_cc_1_connection_src_ix] = new ModelSource(
                            new ModelIdentifier("midi", "channel_pressure"));
                    mc.setSources(src_list_new);
                    connmap.put(extractKeys(mc), mc);
                }
                if (!poly_pressure) {
                    ModelConnectionBlock mc = new ModelConnectionBlock();
                    mc.setDestination(mod_cc_1_connection.getDestination());
                    mc.setScale(mod_cc_1_connection.getScale());
                    ModelSource[] src_list = mod_cc_1_connection.getSources();
                    ModelSource[] src_list_new = new ModelSource[src_list.length];
                    for (int i = 0; i < src_list_new.length; i++)
                        src_list_new[i] = src_list[i];
                    src_list_new[mod_cc_1_connection_src_ix] = new ModelSource(
                            new ModelIdentifier("midi", "poly_pressure"));
                    mc.setSources(src_list_new);
                    connmap.put(extractKeys(mc), mc);
                }
            }

            // Enable Vibration Sound Controllers : 76, 77, 78
            ModelConnectionBlock found_vib_connection = null;
            for (ModelConnectionBlock connection : performer_connections) {
                ModelSource[] sources = connection.getSources();
                if (sources.length != 0
                        && sources[0].getIdentifier().getObject().equals("lfo")) {
                    if (connection.getDestination().getIdentifier().equals(
                            ModelDestination.DESTINATION_PITCH)) {
                        if (found_vib_connection == null)
                            found_vib_connection = connection;
                        else {
                            if (found_vib_connection.getSources().length > sources.length)
                                found_vib_connection = connection;
                            else if (found_vib_connection.getSources()[0]
                                    .getIdentifier().getInstance() < 1) {
                                if (found_vib_connection.getSources()[0]
                                        .getIdentifier().getInstance() >
                                        sources[0].getIdentifier().getInstance()) {
                                    found_vib_connection = connection;
                                }
                            }
                        }

                    }
                }
            }

            int instance = 1;

            if (found_vib_connection != null) {
                instance = found_vib_connection.getSources()[0].getIdentifier()
                        .getInstance();
            }
            ModelConnectionBlock connection;

            connection = new ModelConnectionBlock(
                new ModelSource(new ModelIdentifier("midi_cc", "78"),
                    ModelStandardTransform.DIRECTION_MIN2MAX,
                    ModelStandardTransform.POLARITY_BIPOLAR,
                    ModelStandardTransform.TRANSFORM_LINEAR),
                2000, new ModelDestination(
                    new ModelIdentifier("lfo", "delay2", instance)));
            connmap.put(extractKeys(connection), connection);

            final double scale = found_vib_connection == null ? 0
                    : found_vib_connection.getScale();
            connection = new ModelConnectionBlock(
                new ModelSource(new ModelIdentifier("lfo", instance)),
                new ModelSource(new ModelIdentifier("midi_cc", "77"),
                    new ModelTransform() {
                        double s = scale;
                        public double transform(double value) {
                            value = value * 2 - 1;
                            value *= 600;
                            if (s == 0) {
                                return value;
                            } else if (s > 0) {
                                if (value < -s)
                                    value = -s;
                                return value;
                            } else {
                                if (value < s)
                                    value = -s;
                                return -value;
                            }
                        }
                    }), new ModelDestination(ModelDestination.DESTINATION_PITCH));
            connmap.put(extractKeys(connection), connection);

            connection = new ModelConnectionBlock(
                new ModelSource(new ModelIdentifier("midi_cc", "76"),
                    ModelStandardTransform.DIRECTION_MIN2MAX,
                    ModelStandardTransform.POLARITY_BIPOLAR,
                    ModelStandardTransform.TRANSFORM_LINEAR),
                2400, new ModelDestination(
                    new ModelIdentifier("lfo", "freq", instance)));
            connmap.put(extractKeys(connection), connection);

        }

        // Add default connection blocks
        if (performer.isDefaultConnectionsEnabled())
            for (ModelConnectionBlock connection : defaultconnections)
                connmap.put(extractKeys(connection), connection);
        // Add connection blocks from modelperformer
        for (ModelConnectionBlock connection : performer_connections)
            connmap.put(extractKeys(connection), connection);
        // seperate connection blocks : Init time, Midi Time, Midi/Control Time,
        // Control Time
        List<ModelConnectionBlock> connections = new ArrayList<ModelConnectionBlock>();

        midi_ctrl_connections = new int[128][];
        for (int i = 0; i < midi_ctrl_connections.length; i++) {
            midi_ctrl_connections[i] = null;
        }
        midi_connections = new int[5][];
        for (int i = 0; i < midi_connections.length; i++) {
            midi_connections[i] = null;
        }

        int ix = 0;
        boolean mustBeOnTop = false;

        for (ModelConnectionBlock connection : connmap.values()) {
            if (connection.getDestination() != null) {
                ModelDestination dest = connection.getDestination();
                ModelIdentifier id = dest.getIdentifier();
                if (id.getObject().equals("noteon")) {
                    mustBeOnTop = true;
                    if (id.getVariable().equals("keynumber"))
                        forcedKeynumber = true;
                    if (id.getVariable().equals("velocity"))
                        forcedVelocity = true;
                }
            }
            if (mustBeOnTop) {
                connections.add(0, connection);
                mustBeOnTop = false;
            } else
                connections.add(connection);
        }

        for (ModelConnectionBlock connection : connections) {
            if (connection.getSources() != null) {
                ModelSource[] srcs = connection.getSources();
                for (int i = 0; i < srcs.length; i++) {
                    processSource(srcs[i], ix);
                }
            }
            ix++;
        }

        this.connections = new ModelConnectionBlock[connections.size()];
        connections.toArray(this.connections);

        this.ctrl_connections = new int[ctrl_connections_list.size()];

        for (int i = 0; i < this.ctrl_connections.length; i++)
            this.ctrl_connections[i] = ctrl_connections_list.get(i);

        oscillators = new ModelOscillator[performer.getOscillators().size()];
        performer.getOscillators().toArray(oscillators);

        for (ModelConnectionBlock conn : connections) {
            if (conn.getDestination() != null) {
                if (isUnnecessaryTransform(conn.getDestination().getTransform())) {
                    conn.getDestination().setTransform(null);
                }
            }
            if (conn.getSources() != null) {
                for (ModelSource src : conn.getSources()) {
                    if (isUnnecessaryTransform(src.getTransform())) {
                        src.setTransform(null);
                    }
                }
            }
        }

    }

    private static boolean isUnnecessaryTransform(ModelTransform transform) {
        if (transform == null)
            return false;
        if (!(transform instanceof ModelStandardTransform))
            return false;
        ModelStandardTransform stransform = (ModelStandardTransform)transform;
        if (stransform.getDirection() != ModelStandardTransform.DIRECTION_MIN2MAX)
            return false;
        if (stransform.getPolarity() != ModelStandardTransform.POLARITY_UNIPOLAR)
            return false;
        if (stransform.getTransform() != ModelStandardTransform.TRANSFORM_LINEAR)
            return false;
        return false;
    }
}