/*
 * Created on Nov 16, 2004 
 *
 */
package jmslexamples.jsyn;

import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import com.softsynth.jmsl.JMSL;
import com.softsynth.jmsl.MusicShape;
import com.softsynth.jmsl.jsyn.*;
import com.softsynth.jmsl.jsyn.circuits.BandPassSynthNote;
import com.softsynth.jmsl.score.*;
import com.softsynth.jmsl.util.*;
import com.softsynth.jsyn.circuits.FilteredSawtoothBL;

/**
 * Signal Processing JMSL Score example
 * 
 * Staff 1 performs signal processing on staff 0
 * 
 * Play a rich resonant drone in staff 1
 * Band Pass filter in staff 2
 * Notice that pitches of bandpass "melody" are fractional, and are mapped onto the frequency of the filter
 * 
 * @author Nick Didkovsky, didkovn@mail.rockefeller.edu
 *  
 */
public class SignalProcessingScore2 {

    Score score;
    ScoreFrame scoreFrame;
    SynthNoteAllPortsInstrument dryIns;
    SynthNoteAllPortsInstrumentSP signalProcessingIns;

    public void build() {
        JSynMusicDevice.instance().open();
        buildInstruments();
        initScore();
        buildOrchestra();
        buildScore();
    }

    private void buildInstruments() {
        dryIns = new SynthNoteAllPortsInstrument(8, FilteredSawtoothBL.class.getName());
        dryIns.setName("Droner");
        
        // BandPassSynthNote maps frequency input port to filter frequency, so a "melody" contour will reflect the filter's frequency contour
        signalProcessingIns = new SynthNoteAllPortsInstrumentSP(8, BandPassSynthNote.class.getName());
        signalProcessingIns.setName("Filter");
    }

    private void buildOrchestra() {
        Orchestra orch = new Orchestra();
        orch.addInstrument(dryIns);
        orch.addInstrument(signalProcessingIns);

        // bus signal sources to signal processor
        signalProcessingIns.addSignalSource(dryIns.getOutput());

        // Add this patch to the orchestra's patch list. This way it will
        // save/load to a score xml file
        orch.addOrchPatch(new Patch(0, 1));
        orch.patchInstruments();
        score.setOrchestra(orch);
    }

    private void buildScore() {
        buildSignalSourceMaterial();
        buildSignalProcessingMaterial();
    }

    private void buildSignalSourceMaterial() {
        score.rewind();
        score.setCurrentStaffNumber(0);
        score.getMeasure(0).getStaff(0).setClef(Clef.BASS_CLEF);

        double[] data = MusicShape.getDefaultArray(dryIns.getDimensionNameSpace());
        data[0] = 4.0; // dur
        data[1] = 30; // pitch
        data[3] = 4.0; // hold

        // make a rich resonance drone
        int dimensionOfResonance = dryIns.getDimensionNameSpace().getDimension("resonance");
        data[dimensionOfResonance] = 0.1;
        int dimensionOfCutoff = dryIns.getDimensionNameSpace().getDimension("cutoff");
        data[dimensionOfCutoff] = 3000;

        // whole note tied to a whole note
        Note n = score.addNote(dryIns.getDimensionNameSpace(), data);
        n.setTiedOut(true);
        score.addNote(dryIns.getDimensionNameSpace(), data);
    }

    private void buildSignalProcessingMaterial() {
        score.rewind();
        score.setCurrentStaffNumber(1);

        int numElements = 64;
        int dimensionOfQ = signalProcessingIns.getDimensionNameSpace().getDimension("Q");
        double minQ = signalProcessingIns.getDimensionNameSpace().getLowLimit(dimensionOfQ);
        double maxQ = signalProcessingIns.getDimensionNameSpace().getHighLimit(dimensionOfQ);
        double minPitch = 48;
        double maxPitch = 100;

        LinearInterpolator linearInterp = new LinearInterpolator(0, minQ, numElements, maxQ);
        HalfCosineInterpolator pitchInterpolator = new HalfCosineInterpolator(0, minPitch, numElements, maxPitch);
        double duration = 0.125;
        double[] data = MusicShape.getDefaultArray(signalProcessingIns.getDimensionNameSpace());
        for (int i = 0; i < numElements; i++) {
            data[0] = duration;
            data[1] = pitchInterpolator.interp(i);
            data[4] = linearInterp.interp(i);
            Note n = score.addNote(signalProcessingIns.getDimensionNameSpace(), data);
            if (i % 8 != 7) 
                n.setBeamedOut(true);
        }
    }

    private void initScore() {
        score = new Score(2, 800, 600);
        score.addMeasure(4, 4);
        score.setName("AlgoScore Example 2: Drone with filter");
    }

    public void showScore() {
        scoreFrame = new ScoreFrame();
        scoreFrame.addScore(score);
        scoreFrame.pack();
        scoreFrame.setVisible(true);
        scoreFrame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                JMSL.closeMusicDevices();
                System.exit(0);
            }
        });
    }

    public static void main(String[] args) {
        SignalProcessingScore2 algoScore = new SignalProcessingScore2();
        algoScore.build();
        algoScore.showScore();
    }
}