Muusika

Helilõigud, MIDI, saatehääl, kolmkõlad, kvanditud heli, stereo

Klippide mängimine

Esimesest versioonist peale suudavad java programmid mängida au lihtsamas formaadis faile. Versioonist 1.2 on juurde liidetud ka muude (wav, midi) helifailitüüpide mängimise võimalus. Muusika mängimiseks tuleb luua AudioClip. Selle meetoditega play, loop ning stop saab panna klipi mängima ning mängimine katkestada. Loop tähendab, et klippi mängitakse pidevalt, s.t. pärast lõpetamist hakatakse mängimisega uuesti algusest peale.

import java.applet.*;

public class Muusika1 extends Applet{

public void start(){

AudioClip lugu=getAudioClip(getCodeBase(), "spacemusic.au");

lugu.play();

}

}

Järgneva näite puhul hakatakse korduvalt mängima lehele tulles ning lehelt lahkudes lõpetatakse mängimine.

import java.applet.*;

public class Muusika2 extends Applet{

AudioClip lugu;

public void init(){

lugu=getAudioClip(getCodeBase(), "spacemusic.au");

}

public void start(){

lugu.loop();

}

public void stop(){

lugu.stop();

}

}

Iseseisva programmi puhul saab klipi kätte klassi Applet staatilise meetodi newAudioClip abil, meetodi parameetriks on helifaili URL.

import java.applet.*;

import java.net.URL;

public class Muusika3a{

public static void main(String argumendid[]) throws Exception{

AudioClip lugu=Applet.newAudioClip(

new URL("http://minitorn.tpu.ee/~jaagup/kool/java/"+

"abiinfo/tutorial/sound/example-1dot2/bottle-open.wav")

);

lugu.play();

Thread.sleep(5000);

}

}

Kui soovitakse mängida lugu samast masinast, siis tuleb ka see kohalik aadress enne URLiks muuta.

import java.applet.*;

import java.net.URL;

public class Muusika3{

public static void main(String argumendid[]) throws Exception{

AudioClip lugu=Applet.newAudioClip(

new File("spacemusic.au").toURL()

);

lugu.play();

Thread.sleep(5000);

}

}

MIDI

Lisaks varemvalminud lugude esitamisele saab ka ise meloodiaid kokku panna. MIDI abil saame määrata, millist nooti millal mängida. Salvestatud pillide helinäidete järgi luuakse selle tulemusena meie poolt küsitud hääl. Kui soovitakse samaaegselt kuulda mitme pilli meloodiat, tuleb need paigutada eri kanalitele. Iga kanal võib korraga teha ühe pilli häält ning harilikult on kanaleid kokku kuni 16.

Kanalist väljuvat heli saab kontrollida sinna saadetavate käskudega. Enamkasutatavad on noteOn ja noteOff. Esimene neist palub nooti mängima hakata, teine mängimise lõpetada. Meetod noteOn vajab kahte parameetrit: heli kõrgust ja valjust, noodi kõlamise lõpetamiseks piisab noodi numbrist. MIDI standardi järgi on igal pooltoonil oma number vahemikus 0-127. Esimese oktaavi C väärtuseks on näiteks 60, sealt saab siis vastavalt poole tooni kaupa üles ja allapoole arvutada. Valjust tähistab samuti number samast vahemikust. MIDI vahendid asuvad paketis javax.sound, mis kuulub standardvahendite hulka alates JDK versioonist 1.3. Operatsiooni muusikavahendite poole pöördumiseks saab kasutada klassi MidiSystem.

Üksik noot

Järgnevas näites küsitakse selle klassi kaudu helitekitamise seade ehk süntesaator ning avatakse. Viimase käest küsitakse tema külge kuuluv kanalite massiiv ning sealt omakorda kanal nr. 0. Järgnevalt palun vastaval kanalil mängida A nooti (noot nr. 69) valjusega 65. Ootan sekundi ning siis lasen noodi kõlamise lõpetada. System.exit viimase käsuna on tarvilik, kuna MIDI vahendite tarvitamisega virtuaalmasina poolt loodud lõim ei oska nootide lõpuga oma tööd lõpetada ning programm jääks viimasele reale rippuma. Analoogiline olukord on ka graafikakomponentide juures, kus programmi töö lõpetamiseks tuleb kirjutada System.exit(0).

import javax.sound.midi.*;

public class Noot{

public static void main(String argumendid[]) throws Exception{

Synthesizer synthesizer=MidiSystem.getSynthesizer();

synthesizer.open();

MidiChannel kanal=synthesizer.getChannels()[0]; //kanal 0;

int korgus=69; //A

int valjus=65; //keskmine

kanal.noteOn(korgus, valjus);

Thread.sleep(1000);

kanal.noteOff(korgus);

System.exit(0);

}

}

Kromaatiline heliredel

Kromaatilist heliredelit võib mängida tsükli abil:

for(int i=40; i<120; i++){

kanal.noteOn(i, 60);

Thread.sleep(200);

kanal.noteOff(i);

}

Kui soovida, et samal kanalil mängiks korraga mitu nooti, tuleb lihtsalt ükshaaval määrata, millised helikõrgused peavad kõlama. Kõikide mängimise saab korraga lõpetada käsuga allNotesOff().

Helikõrguse ujumine

Kuigi MIDI puhul öeldakse helikõrgus numbriga ette, on ka siin võimalik toonil ujuda lasta. Seda saab käsuga setPitchBend, andes ette numbri, palju kõrgust muuta. Vaikimisi väärtuseks on 8192, sellisel juhul vastab noodi number tema helikõrgusele. Iga number sellest ülespoole viib helikõrgust kõrgemale, allapoole aga madalamaks. Vaikiva kokkuleppe järgi tähistab number 0 tooni võrra madalamat ning 16363 tooni jagu kõrgemat heli, kuid see kõikumise piirkond võib ka erineda. Järgnevas näites peaks tooni ülalt alla ujumine kuulda olema.

kanal.noteOn(60, 70);

kanal.noteOn(64, 70);

for(int korgus=16383; korgus>0; korgus-=500){

Thread.sleep(200);

kanal.setPitchBend(korgus);

}

kanal.allNotesOff();

Pillide loetelu

Kanalil mängivat instrumenti saab muuta käsuga programChange, andes parameetritena ette uue pilli helipanga ning panga sees sellele pillile vastava programmijupi järjenumbri. Süntesaatorile kättesaadavad pillid saab küsida getDefaultSoundbank().getInstruments() abil. All näites paiknevad trükitakse tsüklis järgemööda välja pillide nimed ning mängitakse igal pillil noot.

Instrument[] pillid=synthesizer.getDefaultSoundbank().

getInstruments();

MidiChannel kanal=synthesizer.getChannels()[0];

for(int i=0; i<pillid.length; i++){

System.out.println(i+": "+pillid[i]);

kanal.programChange(pillid[i].getPatch().getBank(),

pillid[i].getPatch().getProgram());

kanal.noteOn(60, 50);

Thread.sleep(500);

kanal.noteOff(60);

}

osa väljundist:

12: Instrument Marimba (bank 0 program 12)

13: Instrument Xylophone (bank 0 program 13)

14: Instrument Tubular Bell (bank 0 program 14)

15: Instrument Dulcimer (bank 0 program 15)

16: Instrument Hammond Organ (bank 0 program 16)

Rajad

Kanalitele käske andes saab edukalt mängida programmi sees üksikuid noote ja luua kõlaefekte, kuid meloodiate ja viisijuppide esitamiseks on loodud täiendavad abivahendid: sekventser, sekventsid ja rajad. Rajal (track) on kirjas saadetavad teated koos ajatemplitega. Ühele rajale võib kanda näiteks ühe pillimehe mängitavad noodid. Sekvents on radade kogumik (nagu partituur). Sekventser on programmilõik, kes sekventsi kirjutatud käsklused õigel ajal süntesaatorile heli tekitamiseks edasi saadab.

Kanalile saadetava teate hoidmiseks on ShortMessage. Teate sisuks võib olla nii noodi mängimise algus, selle lõpp, kanalil oleva instrumendi vahetus kui muudki, näiteks klahvivajutuse tugevuse muutus. Rajale lisamiseks tuleb teatele ümber panna MidiEvent, mis lisab sinna aja – MIDI ajaühikutes mõõdetava vahemiku alates raja algushetkest. Esimeseks teateks kanalil peab olema PROGRAM_CHANGE, selle abil määratakse, millise pilliga hakatakse vastaval kanalil häält tegema. Siin näites määratakse kanalile 0 pill number 16, ehk praeguse helipanga järgi Hammondi orel.

Sekventsi puhul tuleb määrata, milliselt seal aega arvatakse: kas kaadrite või löökide järgi. Esimest võimalust kasutatakse video kõrvale heli loomiseks, teist nootide ja taktide järgi lugu seades, viimast tähistab Sequence.PPQ nagu siin näites. Käsk new Sequence(Sequence.PPQ, 4) tähistab, et luuakse nootidepõhine sekvents, mille iga löök (ehk veerandnoot 2/4, 3/3 ja 4/4 taktimõõdus) jagatakse neljaks tiksuks. Tiks on vähim ajaühik MIDI mõõdustikus, seega sellise jaotuse korral on võimalik lühimaks kestuseks panna kuueteistkümnendiknoodid. Kui tahta näiteks ka kolmekümnekahendikke kasutada, siis tuleks algselt veerandnoot mitte neljaks vaid kaheksaks tiksuks jagada.

Enne rajale sündmuste lisamist tuleb rada luua sekventsi käsuga createTrack(). Tulemuse kuulamiseks on vaja MidiSystem'i käest küsida sekventser, see avada. Siis määrata, et sekventseri poolt mängitavaks sekventsiks oleks (praegu meie üherajaline) sekvents ning käsuga start panna sekventser tööle.

import javax.sound.midi.*;

public class Rada1{

public static void main(String argumendid[]) throws Exception{

ShortMessage lahti = new ShortMessage();

ShortMessage kinni = new ShortMessage();

ShortMessage algus = new ShortMessage();

algus.setMessage(ShortMessage.PROGRAM_CHANGE, 0, 16, 0);

lahti.setMessage(ShortMessage.NOTE_ON, 0, 65, 93);

kinni.setMessage(ShortMessage.NOTE_OFF, 0, 65, 93);

Sequence sequence=new Sequence(Sequence.PPQ, 4);

Track track=sequence.createTrack();

track.add(new MidiEvent(algus, 0));

track.add(new MidiEvent(lahti, 0));

track.add(new MidiEvent(kinni, 4));

track.add(new MidiEvent(lahti, 8));

track.add(new MidiEvent(kinni, 11));

track.add(new MidiEvent(lahti, 12));

track.add(new MidiEvent(kinni, 15));

track.add(new MidiEvent(lahti, 16));

track.add(new MidiEvent(kinni, 31));

Sequencer sequencer=MidiSystem.getSequencer();

sequencer.open();

sequencer.setSequence(sequence);

sequencer.start();

}

}

Loodud sekvetserile saab seada mitmeid parameetreid, samuti küsida andmeid mängitava loo kohta. Kui tahan määrata, et loo mängimise kiirus on 40 lööki minutis, siis tuleb kirjutada

sequencer.setTempoInBPM(40);

Kuna ennist olin määranud, et ühes löögis on 4 tiksu, siis eelmainitud reast järeldub, et igas minutis on 4*40 ehk 160 tiksu ning ühe tiksu pikkuseks on 60/160 sekundit. Analoogiliselt on võimalik määrata, millisest tiksust alates edasi mängitakse. Sekventseri käest saab küsida mängimise kiirust, temas sisalduva sekventsi ehk lõigu pikkust tiksudes, parasjagu mängitava tiksu numbrit ja muudki.

Kui soovin, et lõiku mitu korda järjest mängitaks, siis tuleb sekventserile panna külge kuular, mis lõputeate saabumisel paluks lõiku taas otsast mängima hakata. Piiritleja final on sekventseri ette toodud seetõttu, et teda saaks kohaliku muutujana sisemises klassis kasutada. Final ei luba muutujal vahetada isendit millele osutada (st., sellele muutujale ei saa anda uut väärtust). Muul juhul võiks juhtuda, et vahepeal pannakse sekventserile uus väärtus ning sisemise klassi sees lükatakse vale sekventser käima. Kui anonüümses sisemises klassis kasutada isendi (või klassi) tarvis kirjeldatud muutujat, siis seda probleemi ei teki.

Kordamine

Lõigu lõppu näitab kuularisse saabuv teade tüübiga nr. 47. Kui seepeale palun sekventseril uuesti otsast mängima hakata, siis tundub kasutajale, nagu lugu kordaks end järjepanu.

final Sequencer sequencer=MidiSystem.getSequencer();

sequencer.open();

sequencer.setSequence(sequence);

sequencer.start();

sequencer.addMetaEventListener(new MetaEventListener(){

public void meta(MetaMessage m){

//kui lugu läbi, siis alustatakse uuesti

if(m.getType()==47)sequencer.start();

}

});

Kui soovida, et sekventsi kordamisel erinevalt mängitaks, siis võib sinna panna mitu rada ning igal korral määrata, milliseid radasid mängitakse, milliseid mitte. Sekventseri käsu setTrackMute abil saab määrata, kas rada on tumm või mitte. Kui soovitakse, et ainult üks rada mängiks ning teised oleksid vait, siis tuleb see rada panna soleerima käsu setTrackSolo abil.

MIDI faili mahamängimine

... on lihtne, sest vastavad vahendid on küllaltki valmiskujul kättesaadavad. Kui arvutis on MIDI väljund (helikaardi kaudu) kõlaritesse või kõrvaklappidesse saadetud ning muusikafail ilusti kettal olemas, siis peaks all näha oleva nelja käsu abil olema võimalik etteantud nimega failist muusikat kuulata. Klassi MidiSystem käsk getSecuence võimaldab sekventsi lugeda failist (või mõnest muust voost). Kui avatud sekventser määrata vastavat sekventsi mängima, siis võimegi kuulata, mis faili salvestatud on.

import javax.sound.midi.*;

public class Midimangija1 {

public static void main(String argumendid[]) throws Exception{

Sequencer sekventser=MidiSystem.getSequencer();

sekventser.open();

sekventser.setSequence(MidiSystem.getSequence(new java.io.File("koduke.mid")));

sekventser.start();

}

}

MIDI failis paiknevate andmete kohta võib muudki teada saada: andmete pikkust mikrosekundites ning tiksudes, radade arvu ning teated ükshaaval radade kaupa. Rajalt saab käsuga get kätte järjekorranumbri järgi MidiEvent'i. Sealt edasi getMessage väljastab teate sisu ning getTick tiksu (ajahetke), millal vastav teade süntesaatorile saadetakse. Tuleb vaadata, millist tüüpi teatega on tegemist ning vastavalt käituda. Helidega seotud teated on tüübist ShortMessage. Iga teate juures on täisarvuna kirjas kanal, käsklus ning kaks teatebaiti. Nende baitide interpretatsioon sõltub sellest, millise käsuga on tegemist.

import javax.sound.midi.*;

import java.util.*;

public class Midimangija2 {

public static void main(String argumendid[]) throws Exception{

Sequence sekvents=MidiSystem.getSequence(new java.io.File("koduke.mid"));

System.out.println(sekvents.getDivisionType()+" pikkus: "+sekvents.getMicrosecondLength()/1000000.0+

" sekundit, "+sekvents.getTickLength()+" tiksu");

Track[] rajad=sekvents.getTracks();

System.out.println(rajad.length+" rada");

for(int nr=0; nr<rajad.length; nr++){

System.out.println("Rada "+nr);

for(int t=0; t<rajad[nr].size(); t++){

MidiEvent me=rajad[nr].get(t);

long tiks=me.getTick();

MidiMessage teade=me.getMessage();

if(teade instanceof ShortMessage){

ShortMessage sm=(ShortMessage)teade;

System.out.println(tiks+" ShortMessage "+

"kanal: "+sm.getChannel()+

" teade: "+sm.getCommand()+ //näiteks noteOff

" bait1: "+sm.getData1()+ //kõrgus

" bait2: "+sm.getData2() //valjus

);

}

if(teade instanceof MetaMessage){

MetaMessage mm=(MetaMessage)teade;

System.out.print(tiks+" MetaMessage"+

" tyyp: "+mm.getType());

byte[] b=mm.getData();

for(int i=0; i<b.length; i++)System.out.print(" "+b[i]);

System.out.println();

}

}

}

}

}

/*

Väljund:

0.0 pikkus: 15.5 sekundit, 2976 tiksu

2 rada

Rada 0

0 MetaMessage tyyp: 88 4 2 24 8

0 MetaMessage tyyp: 89 0 0

0 MetaMessage tyyp: 81 7 -95 32

2976 MetaMessage tyyp: 47

Rada 1

0 ShortMessage kanal: 0 teade: 192 bait1: 1 bait2: 0

0 ShortMessage kanal: 0 teade: 176 bait1: 7 bait2: 80

0 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

96 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

96 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

192 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

192 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 80

288 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 0

288 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

384 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

384 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

480 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

480 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

576 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

576 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

672 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

768 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

864 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

864 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

960 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

960 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 80

1056 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 0

1056 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

1152 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

1152 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

1248 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

1248 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

1344 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

1344 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

1440 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

1536 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

1632 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

1632 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

1728 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

1728 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

1824 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

1824 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

1920 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

1920 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 80

2016 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 0

2016 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 80

2112 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 0

2112 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 80

2208 ShortMessage kanal: 0 teade: 144 bait1: 65 bait2: 0

2304 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

2400 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

2400 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

2496 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

2496 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 80

2592 ShortMessage kanal: 0 teade: 144 bait1: 62 bait2: 0

2592 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 80

2688 ShortMessage kanal: 0 teade: 144 bait1: 64 bait2: 0

2688 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

2784 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

2784 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

2880 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

2880 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 80

2976 ShortMessage kanal: 0 teade: 144 bait1: 60 bait2: 0

2976 MetaMessage tyyp: 47

*/

Nagu näha, seda MIDI faili loonud programm on kasutanud noodi kõlamise alustamiseks ning lõpetamiseks sama käsku (NOTE_ON, 144), vaid mängimise lõpetamise puhul on noodile määratud valjus 0. Kanalile 0 pole muusika kõlamisega seotud noote pandud.

MIDI faili loomine

Sekventsi võib faili kirjutada ühe käsuga, andes ette MIDI formaadi (0 või 1) ning voo, kuhu andmed saata.

MidiSystem.write(sekvents, 1, new FileOutputStream("koduke2.mid"));

Nii võib rahumeeli lasta programmil loo välja mõtelda või kasutaja käest küsida ning siis kettale salvestada, et seda edaspidi kuulata või uuesti muuta. All näites on võetud ette lugu (koduke.mid), sellele lisatud rada ning algse viimase (siin ainukese) raja nootide järgi pandud uuele rajale samad noodid väikese tertsi (3 pooltooni) jagu allapoole. ShortMessage'd on ümber arvutatud, muud muutumatuna üle kantud.

import javax.sound.midi.*;

import java.io.*;

public class Midimangija3 {

public static void main(String argumendid[]) throws Exception{

Sequence sekvents=MidiSystem.getSequence(new File("koduke.mid"));

Track algrada=sekvents.getTracks()[sekvents.getTracks().length-1]; //viimane rada

Track uusrada=sekvents.createTrack();

int nihe=-3;

for(int nr=0; nr<algrada.size(); nr++){

MidiEvent me=algrada.get(nr);

if(me.getMessage() instanceof ShortMessage){

ShortMessage sm=(ShortMessage)me.getMessage();

ShortMessage sm2=new ShortMessage();

if(sm.getCommand()==ShortMessage.NOTE_ON ||

sm.getCommand()==ShortMessage.NOTE_OFF){

sm2.setMessage(

sm.getCommand(), sm.getChannel(), sm.getData1()+nihe, sm.getData2()

);

} else {

sm2=(ShortMessage)sm.clone();

}

uusrada.add(new MidiEvent(sm2, me.getTick()));

} else {

uusrada.add(me);

}

}

MidiSystem.write(sekvents, 1, new FileOutputStream("koduke2.mid"));

}

}

Saateautomaat

Küllap olete näinud ja kuulnud süntesaatorit lugusid saatmas. Mõni koputab lihtsalt rütmi taha, teisele tuleb ette anda helistik ning selle peale mängitakse saateakordi. Leidub ka selliseid saateprogramme, mis vastavalt etteantud helistikule ise saatenoote juurde mõtlevad või lisaks sellele juba mängitava viisi pealt harmoonia ennustavad. Viimase võimaluse jätame siin välja, kuid juurde kuuluva pikema näite ja seletuse läbi töötanud lugeja peaks mõningase pusimise järel esimese kolme osaga küll hakkama saama.

Näites mängitakse saadet Juhansonide Unenäo laulule. Kasutaja saab määrata helistiku ning kuulata bassi, akorde ning taustaks mängitavat rahvalikku viiulipartiid, samuti määrata tempot. Koodi lühiduse ja kompaktsuse huvides pole viisi lisatud, kuid olles seletustest aru saanud, peaks see täiesti jõukohane olema.

Üheaegselt mängitavad rajad luuakse valmis ja pannakse kokku üheks sekventsiks. Rajad, mille heli parajasti kuulda ei soovita, pannakse vaikima. Kuna ühes helistikus mängimisel piirdub lugu kolme duuriga, siis arvutatakse nii bassi kui akordi tarvis välja rajad kõigi kolme duuri jaoks, kuid kõlada lastakse vaid siis, kui kasutaja vastavat instrumenti soovib kõlamas kuulda ning parajasti mängitav duur ja rada kokku langevad. Nii pääseb pidevast nootide arvutamisest ning uued rajad tuleb luua vaid helistiku vahetamisel. Vaid viiulipartii luuakse iga takti algul uuesti, et see tunduks värske ja kordumatuna.

Bassi partii on kõige lihtsam, sestap alustan selle loomise seletamisest. Takti jooksul on bassipartiis vaid üks noot, mängitava akordi esimene aste, mis kõlab kogu takti jooksul. Takt koosneb kolmest löögist, iga löök neljast tiksust (see määrati sekventsi loomisel). Nii peab bass alustama kõlamist tiksust 0 ning lõpetama selle viimase tiksu järel ehk kaheteistkümnenda tiksu alguses. Selle ühe noodi kõlamiseks on vaja rajale kolme teadet: tuleb määrata kanalil kõlama hakkav pill, kõlamise algus ja lõpp. Bass pannakse mängima etteantud põhinoodist 2 oktaavi ehk 24 pooltooni allpoolt.

void looBass(Track t, int toonika){

try{

Kõigepealt tehakse tühjad teated valmis

ShortMessage m[]=new ShortMessage[3];

for(int i=0; i<m.length; i++){

m[i]=new ShortMessage();

}

seejärel antakse neile väärtused

m[0].setMessage(ShortMessage.PROGRAM_CHANGE, 1, 39, 0);

m[1].setMessage(ShortMessage.NOTE_ON, 1, toonika-24, 60);

m[2].setMessage(ShortMessage.NOTE_OFF, 1, toonika-24, 60);

ning lõpuks pannakse rajale, lisades juurde, mitmenda tiksu juures nad aktiivseks peavad muutuma.

t.add(new MidiEvent(m[0], 0));

t.add(new MidiEvent(m[1], 0));

t.add(new MidiEvent(m[2], 12));

}catch(Exception e){e.printStackTrace();}

}

Kolmkõla loomine toimub tehniliselt sarnaselt bassiga võrrelduna. Kui bassi partii koosnes takti jooksul vaid ühest noodist, siis kolmkõla tarvis kõlavad takti jooksul kolm nooti. Esimesel löögil alustatakse põhinoodiga, teisel kolmanda ning kolmandal viienda astmega. Kolmanda löögi lõpus lõpetatakse kõikide nootide kõlamine. Endise kolme teate asemel on nüüd vaja seitset: instrumendi määramiseks ning kõigi kolme noodi kõlamise alustamiseks ja lõpetamiseks.

Et võiks korraga välja arvutada ühe helistiku juures vaja minevad kolmkõla- ning bassirajad, selleks sai loodud meetod, millele antakse ette toonika ning mis väljastab sekventsi kummagi esituse radadega esimese, neljanda ning viienda astme tarvis. Kolmkõlade juures võetakse nii neljas kui viies aste (vastavalt viis ja seitse pooltooni) toonikast üles, bassi puhul alla. Tegemist on täiesti sisetundega, milliselt poolt võtta, kuid siin tundus, et helilõigu keskele sobib sügav mahlakas bass paremini ning lõpus kõrgemas toonikas justkui saabub rahu ja tasakaal. Põhjalikumate saadete puhul tuleb leidmise algoritm tõenäoliselt keerulisemaks teha, et arvestataks ilusti kõlavaid absoluutkõrgusi ning miks mitte ka viisi kulgemist.

Sequence pohikolmkolad(int toonika) throws InvalidMidiDataException{

Sequence s1=new Sequence(Sequence.PPQ, 4);

looKolmkola(s1.createTrack(), toonika);

looKolmkola(s1.createTrack(), toonika+5); //kvart

looKolmkola(s1.createTrack(), toonika+7); //kvint

looBass(s1.createTrack(), toonika);

looBass(s1.createTrack(), toonika-7); //IV ehk kvint alla

looBass(s1.createTrack(), toonika-5);

return s1;

}

Et parasjagu valitud helistiku põhikolmkõladeks saatehääled kätte saada, ka selleks on eraldi — kuigi lühike — alamprogramm.

Sequence looSekvents() throws InvalidMidiDataException{

return pohikolmkolad(helikorgused[helistik.getSelectedIndex()]);

}

Nime all helistik peitub valik ning helistik.getSelectedIndex() annab järjekorranumbri, mitmenda kasutaja oli loetelust valinud. Massiivis helistikud on tähtedega määratud, mitmendal kohal mingi helistik asetseb ning massiiv helikorgused näitab vastavate helistike toonikate asukohad MIDI skaalal. Sõnes jooksevHelistik hoitakse meeles viimati valitud helistiku nimi, et edaspidi oleks võrdlemisel teada, millal kasutaja on helistikku vahetanud, et oleks põhjust saatesekvents uuesti arvutada.

JComboBox helistik=new JComboBox();

String[] helistikud={"Bb", "F", "C", "G", "D", "A", "E"};

int[] helikorgused={58, 53, 60, 55, 50, 57, 52};

String jooksevHelistik="";

Mängitav sekvents ning mängiv sektventser,

Sequence sequence;

Sequencer sequencer;

graafilised vahendid töö juhtimiseks,

JButton nupp=new JButton("Mängi");

JCheckBox ruut=new JCheckBox("Korda");

JCheckBox bass=new JCheckBox("Bass");

JCheckBox akord=new JCheckBox("Akord");

JCheckBox taust=new JCheckBox("Taust");

JRadioButton[] raadionupud=new JRadioButton[3];

String[] raadionupustring={"I", "IV", "V"};

JScrollBar tempo=new JScrollBar(JScrollBar.HORIZONTAL, 190, 5, 40, 320);

rada viiulipartii paigutamiseks.

Track muutuvRada;

Diatoonilise duuri astmetele vastavate pooltoonide arv, et hiljem oleks võimalik määrata, mitmendale astmele liikuda ning see arvutile pooltoonides selgeks teha.

static final int[] noodivahed={-1, 0, 2, 4, 5, 7, 9, 11, 12};

//toonika kohal 1 väärtus 0

Konkreetse loo duuride järjestus.

int[] duurid={0, 1, 2, 0, 1, 2, 0, 0}; // Juhansonide unenäo laul

// 0- toonika, 1-IV, 2-V

int duurinr=0; //mängitava takti järjekorranumber

Taustaks mängib viiul lihtsa algoritmi järgi: alustatakse kõlava duuri esimeselt astmelt ning liigutakse iga noodiga sellelt ühe võrra kas üles või alla juhuslikult võetuna. Sellisena satub rõhuline noot kokku kõlava akordiga ning taustaks kõlab ühtlane meloodiline saagimine. Veidi parandades ning ebaloogilisi järske üleminekuid vältides annaks loomulikkust suurendada, kuid ka sellisel kujul ei riiva hullusti kõrva ning viiulimängu algusest alustades tuleks tükk harjutada, et selliselegi tulemusele jõuda.

Et algoritm arvestab diatooniliste astmetega, MIDI aga loeb kõik pooltoonid samaväärseteks siis on loodud ümberarvutamiseks eraldi alamprogramm, millele antakse ette algne aste ja soovitav nihe ning mis väljastab vahe pooltoonides, lubades ka ühe oktaavi piirest välja nihkuda.

static int pooltoonid(int aste, int muutus){

int loppaste=aste+muutus;

int okt=loppaste/7;

if(loppaste<0)okt--;

loppaste=loppaste-7*okt;

int vahe=noodivahed[loppaste]-noodivahed[aste];

return vahe+12*okt;

}

Meetodile enesele antakse ette rada, kuhu teated panna, toonikanoodinumber ning aste, millelt mängimist alustada.

void looTaustaviiul(Track t, int toonika, int aste){

try{

Kõigepealt luuakse mäluruum arvutustulemuste paigutamiseks soovitud arvu leitud nootide tarvis,

int nootidearv=6;

int[] samm=new int[nootidearv];

int i=0;

samm[i++]=0;

siis arvutatakse eelpool kirjeldatud algoritmi järgi väärtused nootidele, kusjuures iga järgmine asub eelmise kõrval

while(i<nootidearv){

if(Math.random()<0.5){

samm[i]=samm[i-1]-1;

} else {

samm[i]=samm[i-1]+1;

}

i++;

}

ning lõpuks asendatakse leitud astmed MIDI teadetega. Ette nagu ikka pilli määramine, sedakorda kanalile number 2.

ShortMessage m=new ShortMessage();

m.setMessage(ShortMessage.PROGRAM_CHANGE, 2, 41, 0);

t.add(new MidiEvent(m, 0));

for(i=0; i<nootidearv; i++){

m=new ShortMessage();

Iga helikõrguse arvutamiseks liidetakse kokku helistiku põhikõrgus (toonika), pooltoonide arv kõlava duuri põhitoonini jõudmiseks (noodivahed[aste]) ning takti jooksul sellest nihkutud astmete arv pooltoonidena (pooltoonid(aste, samm[i])).

m.setMessage(ShortMessage.NOTE_ON, 2,

toonika+noodivahed[aste]+pooltoonid(aste, samm[i]), 60);

t.add(new MidiEvent(m, i*2));

m=new ShortMessage();

m.setMessage(ShortMessage.NOTE_OFF, 2,

toonika+noodivahed[aste]+pooltoonid(aste, samm[i]), 60);

t.add(new MidiEvent(m, (i+1)*2));

}

}catch(Exception e){e.printStackTrace();}

}

Hoolitsemaks, et mängitaks vaid nendel radadel, mille kuulamist kasutaja ootab, tuleb ülejäänud vaikima määrata. Sobivat duuri näitab raadionupp. Siin näites määrab selle valitu programm, kuid kergesti võib ka inimesel lasta määrata, mitmenda astme kolmkõla ta soovib saateks kuulata.

void paneSoolo(){

for(int i=0; i<raadionupud.length; i++){

sequencer.setTrackMute(i, !raadionupud[i].isSelected() || !akord.isSelected());

sequencer.setTrackMute(3+i, !raadionupud[i].isSelected() || !bass.isSelected());

}

Taustaviiul jäetakse kõlama vaid siis, kui vastav ruut on märgitud.

sequencer.setTrackMute(6, !taust.isSelected());

}

Iga uue takti mängimisel tuleb teha mõned ettevalmistused.

void alusta(){

try{

Kui kasutaja on helistikku vahetanud, tuleb kogu sekvents uuesti arvutada.

if(!jooksevHelistik.equals(helistik.getSelectedItem())){

sequence=looSekvents();

jooksevHelistik=helistik.getSelectedItem().toString();

}

Kui tegemist pole loo algusega, siis tuleb kustutada eelmises taktis mängitud viiulipartii

if(muutuvRada!=null)sequence.deleteTrack(muutuvRada);

ning luua uus rada uue partii paigutamiseks.

muutuvRada=sequence.createTrack();

int pohitoon=helikorgused[helistik.getSelectedIndex()];

int aste=1;

if (duurid[duurinr]==1)aste=4;

if (duurid[duurinr]==2)aste=5;

ja arvutada sinna noodid.

looTaustaviiul(muutuvRada, pohitoon, aste);

sequencer.setSequence(sequence);

Mängitava duuri raadionupp märgistada,

raadionupud[duurid[duurinr]].setSelected(true);

leida järgmise korra jaoks järgneva takti number või suunata lugu algusse tagasi

duurinr=(duurinr+1)%duurid.length;

ning lõpuks väljundisse lugu mängima hakata.

mangi();

}catch(Exception e){e.printStackTrace(); System.out.println(e);}

}

Mängimise tarvis tuleb

void mangi(){

kõigepealt sekventser tööle panna

sequencer.start();

alles seejärel saab määrata, millised rajad vaikivad

paneSoolo();

ning kui kiiresti muusika liigub.

sequencer.setTempoInBPM(tempo.getValue());

}

Siia meetodisse saadetakse teade sekventsi lõppemise kohta. Kui kasutaja soovib jätkamist, hakatakse uuesti otsast peale, muul juhul lõpetatakse mängimine ning vabastatakse ressursid teiste programmide tarvis.

public void meta(MetaMessage m){

if(m.getType()==47 && ruut.isSelected()){

alusta();

} else {

sequencer.close();

}

}

Töölesaamise käivitusprogramm on ikka standardne. Tuleb vaid hoolitseda, et init-meetod käima pandaks. Rakendina käivitamisel jääb siinne staatiline meetod sootuks täitmata. Sõltuvalt masina jõudlusest ja konfiguratsioonist võib mõnikord kohalikult kettalt iseseisva programmi või rakendina siinse saateprogrammi käivitamine sujuvama tulemuse ande kui üle võrgu tööle panek, sest sel juhul kipub vähemalt aeglasemate masinate korral õiguste kontrolliks kuuldavalt aega kuluma.

public static void main(String argumendid[]){

JFrame f=new JFrame("Saade");

Noodirakend9a ap=new Noodirakend9a();

ap.init();

f.getContentPane().add(ap);

f.pack();

f.setVisible(true);

}

Siit lehekülgedelt aga peaks olema võimalik leida piisavalt ideid ja soovitusi süntesaatori programmeerimiseks, et mõningane maitse suhu saada ning muusikateadmisi ja keerulisematel juhtudel ka raamatuid appi võttes saaks midagi täiesti kasutatavat kokku panna.

import javax.sound.midi.*;

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

import java.util.*;

public class Noodirakend9a extends JApplet implements ActionListener, MetaEventListener{

Sequence sequence;

Sequencer sequencer;

JButton nupp=new JButton("Mängi");

JCheckBox ruut=new JCheckBox("Korda");

JCheckBox bass=new JCheckBox("Bass");

JCheckBox akord=new JCheckBox("Akord");

JCheckBox taust=new JCheckBox("Taust");

JComboBox helistik=new JComboBox();

JRadioButton[] raadionupud=new JRadioButton[3];

String[] raadionupustring={"I", "IV", "V"};

JScrollBar tempo=new JScrollBar(JScrollBar.HORIZONTAL, 190, 5, 40, 320);

Track muutuvRada;

String[] helistikud={"Bb", "F", "C", "G", "D", "A", "E"};

int[] helikorgused={58, 53, 60, 55, 50, 57, 52};

String jooksevHelistik="";

static final int[] noodivahed={-1, 0, 2, 4, 5, 7, 9, 11, 12}; //toonika kohal 1 väärtus 0

int[] duurid={0, 1, 2, 0, 1, 2, 0, 0}; // Juhansonide unenäo laul

// 0- toonika, 1-IV, 2-V

int duurinr=0; //takti järjekorranumber

void looKolmkola(Track t, int toonika){

try{

ShortMessage m[]=new ShortMessage[7];

for(int i=0; i<m.length; i++){

m[i]=new ShortMessage(); // Tühjad teated valmis

}

m[0].setMessage(ShortMessage.PROGRAM_CHANGE, 0, 25, 0); //pill nr 25 rajale 0

m[1].setMessage(ShortMessage.NOTE_ON, 0, toonika, 60);

m[2].setMessage(ShortMessage.NOTE_ON, 0, toonika+4, 60); //terts rajale 0 valjusega 60

m[3].setMessage(ShortMessage.NOTE_ON, 0, toonika+7, 60); //kvint

m[4].setMessage(ShortMessage.NOTE_OFF, 0, toonika, 60);

m[5].setMessage(ShortMessage.NOTE_OFF, 0, toonika+4, 60);

m[6].setMessage(ShortMessage.NOTE_OFF, 0, toonika+7, 60);

t.add(new MidiEvent(m[0], 0));

for(int i=1; i<4; i++){

t.add(new MidiEvent(m[i], (i-1)*4)); // nelja tiksu (ühe löögi) tagant

} // noodid sisse

for(int i=4; i<7; i++){

t.add(new MidiEvent(m[i], 12)); // 12nda tiksu juures vaikus

}

}catch(Exception e){

e.printStackTrace();

}

}

void looBass(Track t, int toonika){

try{

ShortMessage m[]=new ShortMessage[3];

for(int i=0; i<m.length; i++){

m[i]=new ShortMessage();

}

m[0].setMessage(ShortMessage.PROGRAM_CHANGE, 1, 39, 0);

m[1].setMessage(ShortMessage.NOTE_ON, 1, toonika-24, 60);

m[2].setMessage(ShortMessage.NOTE_OFF, 1, toonika-24, 60);

t.add(new MidiEvent(m[0], 0));

t.add(new MidiEvent(m[1], 0));

t.add(new MidiEvent(m[2], 12));

}catch(Exception e){e.printStackTrace();}

}

static int pooltoonid(int aste, int muutus){

int loppaste=aste+muutus;

int okt=loppaste/7;

if(loppaste<0)okt--;

loppaste=loppaste-7*okt;

int vahe=noodivahed[loppaste]-noodivahed[aste];

return vahe+12*okt;

}

void looTaustaviiul(Track t, int toonika, int aste){

try{

int nootidearv=6;

int[] samm=new int[nootidearv];

int i=0;

samm[i++]=0;

while(i<nootidearv){

if(Math.random()<0.5){

samm[i]=samm[i-1]-1;

} else {

samm[i]=samm[i-1]+1;

}

i++;

}

ShortMessage m=new ShortMessage();

m.setMessage(ShortMessage.PROGRAM_CHANGE, 2, 41, 0);

t.add(new MidiEvent(m, 0));

for(i=0; i<nootidearv; i++){

m=new ShortMessage();

m.setMessage(ShortMessage.NOTE_ON, 2, toonika+noodivahed[aste]+pooltoonid(aste, samm[i]), 60);

t.add(new MidiEvent(m, i*2));

m=new ShortMessage();

m.setMessage(ShortMessage.NOTE_OFF, 2, toonika+noodivahed[aste]+pooltoonid(aste, samm[i]), 60);

t.add(new MidiEvent(m, (i+1)*2));

}

}catch(Exception e){e.printStackTrace();}

}

Sequence pohikolmkolad(int toonika) throws InvalidMidiDataException{

Sequence s1=new Sequence(Sequence.PPQ, 4);

looKolmkola(s1.createTrack(), toonika);

looKolmkola(s1.createTrack(), toonika+5); //kvart

looKolmkola(s1.createTrack(), toonika+7); //kvint

looBass(s1.createTrack(), toonika);

looBass(s1.createTrack(), toonika-7); //IV ehk kvint alla

looBass(s1.createTrack(), toonika-5);

return s1;

}

Sequence looSekvents() throws InvalidMidiDataException{

return pohikolmkolad(helikorgused[helistik.getSelectedIndex()]);

}

void paneSoolo(){

for(int i=0; i<raadionupud.length; i++){

sequencer.setTrackMute(i, !raadionupud[i].isSelected() || !akord.isSelected());

sequencer.setTrackMute(3+i, !raadionupud[i].isSelected() || !bass.isSelected());

}

sequencer.setTrackMute(6, !taust.isSelected());

}

void mangi(){

sequencer.start();

paneSoolo();

sequencer.setTempoInBPM(tempo.getValue());

}

void alusta(){

try{

if(!jooksevHelistik.equals(helistik.getSelectedItem())){

sequence=looSekvents();

jooksevHelistik=helistik.getSelectedItem().toString();

}

if(muutuvRada!=null)sequence.deleteTrack(muutuvRada);

muutuvRada=sequence.createTrack();

int pohitoon=helikorgused[helistik.getSelectedIndex()];

int aste=1;

if (duurid[duurinr]==1)aste=4;

if (duurid[duurinr]==2)aste=5;

looTaustaviiul(muutuvRada, pohitoon, aste);

sequencer.setSequence(sequence);

raadionupud[duurid[duurinr]].setSelected(true);

duurinr=(duurinr+1)%duurid.length;

mangi();

}catch(Exception e){e.printStackTrace(); System.out.println(e);}

}

public void init(){

Panel nupupaneel=new Panel(new GridLayout(1, 4));

helistik=new JComboBox(helistikud);

helistik.setSelectedIndex(3);

nupupaneel.add(helistik);

ButtonGroup nupugrupp=new ButtonGroup();

for(int i=0; i<raadionupud.length; i++){

raadionupud[i]=new JRadioButton(raadionupustring[i]);

nupugrupp.add(raadionupud[i]);

nupupaneel.add(raadionupud[i]);

}

raadionupud[0].setSelected(true);

ruut.setSelected(true);

Panel mangupaneel=new Panel(new GridLayout(1, 2));

mangupaneel.add(nupp);

mangupaneel.add(ruut);

JPanel tempopaneel=new JPanel(new BorderLayout());

tempopaneel.add(new JLabel("Tempo"), BorderLayout.WEST);

tempopaneel.add(tempo, BorderLayout.CENTER);

JPanel valikupaneel=new JPanel(new GridLayout(1, 3));

valikupaneel.add(bass);

valikupaneel.add(akord);

valikupaneel.add(taust);

akord.setSelected(true);

JPanel alumine=new JPanel(new GridLayout(3, 1));

alumine.add(tempopaneel);

alumine.add(mangupaneel);

alumine.add(valikupaneel);

getContentPane().add(alumine, BorderLayout.SOUTH);

getContentPane().add(nupupaneel, BorderLayout.NORTH);

nupp.addActionListener(this);

}

public void actionPerformed(ActionEvent e){

try{

sequencer=MidiSystem.getSequencer();

sequencer.open();

sequencer.addMetaEventListener(this);

jooksevHelistik="";

alusta();

}catch(Exception ex){

ex.printStackTrace();

System.out.println(ex);

}

}

public void meta(MetaMessage m){

if(m.getType()==47 && ruut.isSelected()){

alusta();

} else {

sequencer.close();

}

}

public static void main(String argumendid[]){

JFrame f=new JFrame("Saade");

Noodirakend9a ap=new Noodirakend9a();

ap.init();

f.getContentPane().add(ap);

f.pack();

f.setVisible(true);

}

}

MIDI redaktor

Järgnevalt näide, kus ühendatud Java MIDI-vahendid failide lugemiseks, mängimiseks, muutmiseks ja salvestamiseks ning Swingi võimalused kasutajaliidese loomisel. Näite on koostanud TPÜ üliõpilane Kaur Männiko graafika ja muusika programmeerimise kursuse kodutööna. Näide võimaldab avada ja luua MIDI sekventse. Vaadata radu ning neid kopeerida nii sekventsi sees kui sekventside vahel. Raja sees saab vaadata ja muuta kõiki teateid. Olles näite korralkult läbi mõelnud, peaks olema API spetsifikatsiooni järgi võimalik luua enamikke MIDI-rakendusi, mille jaoks ideid ja vajadusi on.

Graafilisest liidesest võtavad suurema osa enese alla Swingi puu ning tabel. Esimene avatud failide/sekventside ning nende sees olevate radade loeteluks. Tabelis on näha märgistatud rajal asuvad teated toimumise järjekorras koos oma tähtsamate andmetega.

Järgnevalt koodis leiduvate tähelepanu nõudvate lõikude kirjeldus järjemööda.

Märgitud piirkonna mahamängimiseks on loodud eraldi alamprogramm. Puu käest küsitakse kasutaja märgitud komponent ning asutakse käituma vastavalt sellele, mida kasutaja märkinud oli. Mängimiseks sobivad sekvents ning rada. Esimesel puhul paikneb puu viimase lehe ehk node sees NodeObjectHolder, milles omakorda sekvents. Sekventsi saab omaette tervikuna mängima panna.

public void play() {

try {

Object src = tree.getLastSelectedPathComponent();

...

DefaultMutableTreeNode node = (DefaultMutableTreeNode) src;

if ( node.getUserObject() instanceof NodeObjectHolder) {

sekvents = (Sequence)

((NodeObjectHolder)node.getUserObject()).userObject;

} else if( node.getUserObject() instanceof Track) {

Raja mängitamiseks tuleb luua uus sekvents selle sekventsi parameetritega, milles mängitav rada on ning siis rajas olevad teated uue sekventsi loodavale rajale üle kanda.

Track algrada = (Track)node.getUserObject();

sekvents = (Sequence) ((NodeObjectHolder)

((DefaultMutableTreeNode)node.getParent()).getUserObject() ).userObject;

sekvents = new Sequence(sekvents.getDivisionType(), sekvents.getResolution());

Track uusrada = sekvents.createTrack();

for (int nr = 0; nr < algrada.size(); nr++)

uusrada.add(algrada.get(nr));

Sekventsi käivitamiseks piisab kahest käsust.

sekventser.setSequence(sekvents);

sekventser.start();

Klassil küljes olev TreeSelectionListener näitab, et KMidi eksemplar peab oskama ümber käia puu küljest tulevate teadetega. Kui puus valitakse uus koht, saabub selle kohta teade valueChanged käsu kaudu. Edasi kontrollitakse, et juhul kui valituks osutus rada ehk Track-tüüpi leht, siis luuakse uus TableModel ning selle kaudu palutakse paremal pool asuval tabelil näidata just valitud raja sees olevaid teateid.

Nii veerunimede kui raja jaoks loodud muutujad on piiritlejaga final, et sisemise klassi loomisel võiks sealne kood kindel olla, et muutuja külge seotud objekt ikka sinna püsima jääb ning keegi seda ära vahetada ei saa. Abstraktsest tabelimudelist tabeli jaoks tarviliku objekti kokkupanekul tuleb üle katta peotäis käsklusi, mis annavad teavet tabeli sisalduse kohta või lubavad ka seda muuta. Niisuguse mudeli kaudu ei pruugi sugugi alati kõik näidatavad väärtused kahemõõtmelises massiivis asuma, vaid võidakse võtta kusagilt mujalt või sootuks käigu peal valmis arvutada. Siin näites hoitakse andmeid raja sees ning tabel on vaid sealsete väärtuste peegliks.

Tabeli mudel on loodud KMidi sees sisemise anonüümse klassina. Paistab new AbstractTableModel(){} ning nende loogeliste sulgude vahele on paigutatud kogu ülekaetavate käskude loetelu koos sisuga. Nagu käskude nimedestki näha getColumnName annab veeru järjekorranumbrile vastava pealkirja. getColumnCount ja getRowCount teatavad, palju peaks sellele mudelile vastavas tabelise ridasid ja veerge olema. Põhjalikumad käsklused on getValueAt ning setValueAt.

Nende abil saab küsida või määrata tabeli konkreetses lahtris asuvat väärtust.

Sõltumata küsitavast veerust küsitakse rajast kõigepealt reanumbrile vastav sündmus ning asutakse selle sisu uurima. Tiksu väärtus leidub sõltumata sündmuse tüübist ning see küsitakse eraldi muutujasse. Edasi toimetatakse vastavalt sündmuse tüübile. Üldjuhul muusikalise teate ehk ShortMessage puhul leitakse kanali ja käskluse koodid ning mõlemad andmebaidid. MetaMessage puhul antakse vaid tiks või tüübi kood (nt. raja lõpp 47).

Andmete seadmisel setValueAt puhul antakse ette uus väärtus ning rida ja veerg, kuhu soovitakse see väärtus paigutada. Rea järgi otsitakse üles vastav MIDI tiks, veeru järgi parameeter selle sees. Luuakse uus teade ning asendatakse muudetav väärtus, muud kopeeritakse. Edasi pannakse uus teade vana asemele.

getColumnClass ning isCellEditable toimivad nii nagu nimigi määrab. Esimene teatab, millise Java klassile vastavate andmetega tegemist on. Teine vastab, kas vastava veeru andmeid tabelis muuta lubatakse.

Edasi järgnevad mõned käsklused radade haldamiseks puus. copyTrack paigutab märgistatud raja osuti ajutisse muutujasse. getCurrentSequence leiab märgistatud kohale vastava sekventsi. Kui märgistatud on sekvents, väljastatakse osuti sellele enesele. Kui aga rada, siis leitakse sekvents, millesse vastav rada kuulub. newSequence loob uue sekventsi, leiab selle nime ning palub sekventsi puusse paigutada. pasteTrack loob märgistatud sekventsi sisse uue raja ning lisab sellesse eelnevalt meelde jäetud rajal paiknevad teated. Uuele rajale kantakse üle vaid teadete osutid, teadetest endist koopiaid ei tehta. Alles siis, kui kasutaja soovib tabeli kaudu muuta teates paiknevaid parameetreid, luuakse endise asemele uus teate eksemplar.

Sekventsi puuse lisamise eest hoolitseb addSequenceToTree. Sekventsi (faili) nimi tehakse rasvaseks HTML-i käskude abil, mida on Swingi komponentide juures lubatud kujunduseks kasutada. Kõikide sekventsis asuvate radade tarbeks luuakse puus esitamise jaoks tarvilikud DefaultMutableTreeNode tüüpi komponendid.

Järgnev kood on juba küllalt tavapärane pea iga Swingi rakenduses puhul. actionPerformed sündmuste haldamiseks. Faili lugemisel paigutatakse tekstifailis olevad andmed sekventsi, salvestamisel aga talletatakse sekventsi andmed MIDI-faili.

Menüü juures on tarvis vähemasti kolm osa. JMenuBar tähistab kogu menüüriba, JMenu ühte menüüpaneeli ning sinna külge JMenuItem, mille kaudu juba inimene käsklusi anda saab. Ning edasi juba head katsetamist ning jõudu näite põhjal omale tarviliku rakenduse koostamisel.

import javax.swing.*;

import java.awt.event.ActionListener;

import java.awt.event.ActionEvent;

import java.io.IOException;

import java.io.File;

import java.util.*;

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import javax.sound.midi.*;

import javax.swing.tree.*;

import javax.swing.table.*;

import javax.swing.event.*; //TreeSelectionListener, -event

/**

* Midi-redaktor. Koostanud TPÜ Informaatika üliõpilane Kaur Männiko

* graafika ja muusika programmeerimise kursuse kodutööna.

*/

public class KMidi extends JPanel implements ActionListener, TreeSelectionListener {

Sequence sekvents;

Sequencer sekventser;

JButton btnPlay, btnStop, btnNew, btnCopy, btnCut, btnPaste, btnDelete;

JScrollPane treeView;

final JTree tree;

final JTable table;

File file;

DefaultMutableTreeNode rootNode;

DefaultTreeModel treeModel;

public void play() {

try {

Object src = tree.getLastSelectedPathComponent();

if (!(src instanceof DefaultMutableTreeNode))

return;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) src;

if (node.getUserObject() == null)

return;

if ( node.getUserObject() instanceof NodeObjectHolder) {

sekvents = (Sequence) ((NodeObjectHolder)node.getUserObject()).userObject;

} else if( node.getUserObject() instanceof Track) {

Track algrada = (Track)node.getUserObject();

sekvents = (Sequence) ((NodeObjectHolder) ((DefaultMutableTreeNode)node.getParent()).getUserObject() ).userObject;

sekvents = new Sequence(sekvents.getDivisionType(), sekvents.getResolution());

Track uusrada = sekvents.createTrack();

for (int nr = 0; nr < algrada.size(); nr++)

uusrada.add(algrada.get(nr));

} else

return; //root

sekventser.setSequence(sekvents);

sekventser.start();

} catch (InvalidMidiDataException e) {e.printStackTrace();};

}

public void stop() {

sekventser.stop();

}

public KMidi() {

super(new BorderLayout());

JToolBar toolbar = new JToolBar();

btnPlay = new JButton("Play");

btnPlay.addActionListener(this);

toolbar.add(btnPlay);

btnStop = new JButton("Stop");

btnStop.addActionListener(this);

toolbar.add(btnStop);

btnNew = new JButton("Uus");

btnNew.addActionListener(this);

toolbar.add(btnNew);

btnCopy = new JButton("Kopeeri");

btnCopy.addActionListener(this);

toolbar.add(btnCopy);

btnCut = new JButton("Lõika");

btnCut.addActionListener(this);

toolbar.add(btnCut);

btnPaste = new JButton("Kleebi");

btnPaste.addActionListener(this);

toolbar.add(btnPaste);

btnDelete = new JButton("Kustuta");

btnDelete.addActionListener(this);

toolbar.add(btnDelete);

toolbar.setOrientation(JToolBar.HORIZONTAL);

add(toolbar, BorderLayout.NORTH);

rootNode = new DefaultMutableTreeNode("MidiSystem");

treeModel = new DefaultTreeModel(rootNode);

tree = new JTree(treeModel);

tree.addTreeSelectionListener(this);

treeView = new JScrollPane(tree);

treeView.setPreferredSize(new Dimension(300,200));

add(treeView, BorderLayout.WEST);

table = new JTable();

JScrollPane scrollpane = new JScrollPane(table);

add(scrollpane, BorderLayout.CENTER);

try {

sekventser = MidiSystem.getSequencer();

if (!sekventser.isOpen()) {

System.out.print("avatakse sekventser...");

sekventser.open();

System.out.println(" ok");

}

} catch (MidiUnavailableException e) {e.printStackTrace();};

}

public void valueChanged(TreeSelectionEvent e) {

Object src = e.getPath().getLastPathComponent();

if (!(src instanceof DefaultMutableTreeNode))

return;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) src;

if (node.getUserObject() == null)

return;

if(!( node.getUserObject() instanceof Track))

return;

final Track track = (Track) node.getUserObject();

final String[] columnNames = {"Tiks",

"Kanal",

"Teade",

"kõrgus",

"valjus",

"Meta tüüp"};

TableModel dataModel = new AbstractTableModel() {

public String getColumnName(int column) { return columnNames[column];}

public int getColumnCount() { return columnNames.length; }

public int getRowCount() { return track.size();}

public Object getValueAt(int row, int col) {

MidiEvent me = track.get(row);

Long tick = new Long(me.getTick());

MidiMessage msg = me.getMessage();

if (msg instanceof ShortMessage){

ShortMessage sm = (ShortMessage)msg;

switch (col) {

case 0: return tick;

case 1: return new Integer(sm.getChannel());

case 2: return new Integer(sm.getCommand());

case 3: return new Integer(sm.getData1());

case 4: return new Integer(sm.getData2());

default: return "";

}

}

else if (msg instanceof MetaMessage){

MetaMessage mm = (MetaMessage)msg;

switch (col) {

case 0: return tick;

case 5: return new Integer(mm.getType());

default: return "";

}

}

else if (col == 0)

return tick;

else

return "";

}

public Class getColumnClass(int c) {

//return getValueAt(0, c).getClass();

//return Class.forName("Integer");

return (new Long(0)).getClass();

}

public void setValueAt(Object aValue, int row, int col) {

System.out.println("set value "+row+","+ col);

MidiEvent me = track.get(row);

Long tick = new Long(me.getTick());

MidiMessage msg = me.getMessage();

if (col == 0) {

me.setTick(((Long)aValue).longValue());

return;

}

int val = ((Long)aValue).intValue();

if (msg instanceof ShortMessage){

ShortMessage sm = (ShortMessage)msg;

int command = sm.getCommand();

int channel = sm.getChannel();

int data1 = sm.getData1();

int data2 = sm.getData2();

int status = sm.getStatus();

System.out.println("enne muutmist: "+command+","+channel+","+data1+","+ data2);

switch (col) {

//case 0: me.setTick(val);

case 1: channel = val; break;

case 2: command = val; break;

case 3: data1 = val; break;

case 4: data2 = val; break;

}

System.out.println("muudetakse: "+command+","+channel+","+data1+","+ data2);

try {

ShortMessage sm2 = new ShortMessage();

sm2.setMessage(command, channel, data1, data2);

MidiEvent me2 = new MidiEvent(sm2, me.getTick());

track.remove(me);

track.add(me2);

} catch (InvalidMidiDataException ex) {

ex.printStackTrace();

}

}

}

public boolean isCellEditable(int row, int col) {

if (col == 5)

return false;

else

return true;

}

};

table.setModel(dataModel);

}

Track tempTrack = null;

public void copyTrack() {

if (tree.getLastSelectedPathComponent() == null) return;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

if( node.getUserObject() instanceof Track) {

tempTrack = (Track)node.getUserObject();

} else

return; //root

}

private Sequence getCurrentSequence() {

Sequence seq = null;

if (tree.getLastSelectedPathComponent() == null) return null;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

if ( node.getUserObject() instanceof NodeObjectHolder) {

seq = (Sequence) ((NodeObjectHolder)node.getUserObject()).userObject;

} else if( node.getUserObject() instanceof Track) {

Track algrada = (Track)node.getUserObject();

seq = (Sequence) ((NodeObjectHolder) ((DefaultMutableTreeNode)node.getParent()).getUserObject() ).userObject;

}

return seq;

}

private int jnr = 0;

public void newSequence() {

sekvents = getCurrentSequence();

if (sekvents == null) return;

try{

sekvents = new Sequence(sekvents.getDivisionType(), sekvents.getResolution());

//addSeqenceToTree(sekvents, "uus-"+(new Integer(jnr++)).toString()+".mid");

addSeqenceToTree(sekvents, "uus-"+(jnr++)+".mid");

}catch (InvalidMidiDataException e) {e.printStackTrace();}

}

public void cutTrack() {

copyTrack();

deleteTrack();

}

public void pasteTrack() {

if (tree.getLastSelectedPathComponent() == null) return;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

if ( node.getUserObject() instanceof Track)

node = (DefaultMutableTreeNode)node.getParent();

if (!( node.getUserObject() instanceof NodeObjectHolder))

return;

sekvents = (Sequence) ((NodeObjectHolder) node.getUserObject() ).userObject;

Track uusrada = sekvents.createTrack();

for (int nr = 0; nr < tempTrack.size(); nr++)

uusrada.add(tempTrack.get(nr)); //NB! ei tee uusi eksemplare

DefaultMutableTreeNode trackNode = new DefaultMutableTreeNode(uusrada);

node.add(trackNode);

treeModel.insertNodeInto(trackNode, node, 0);

}

public void deleteTrack() {

if (tree.getLastSelectedPathComponent() == null) return;

DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

if( node.getUserObject() instanceof Track) {

Sequence sekvents = (Sequence) ((NodeObjectHolder) ((DefaultMutableTreeNode)node.getParent()).getUserObject() ).userObject;

Track track = (Track)node.getUserObject();

sekvents.deleteTrack(track);

treeModel.removeNodeFromParent(node);

} else

return; //root

}

public void addSeqenceToTree(Sequence seq, String name) {

DefaultMutableTreeNode sequenceNode = null;

DefaultMutableTreeNode trackNode = null;

NodeObjectHolder noh = new NodeObjectHolder("<html><b>" + name + "</b></html>", seq);

sequenceNode = new DefaultMutableTreeNode(noh);

Track[] rajad = seq.getTracks();

System.out.println(rajad.length+" rada");

for (int nr = 0; nr < rajad.length; nr++){

trackNode = new DefaultMutableTreeNode(rajad[nr]);

sequenceNode.add(trackNode);

}

treeModel.insertNodeInto(sequenceNode, rootNode, rootNode.getChildCount());

}

public void actionPerformed(ActionEvent e) {

if (e.getSource() == btnPlay) {

play();

} else if (e.getSource() == btnStop) {

stop();

} else if (e.getSource() == btnCopy) {

copyTrack();

} else if (e.getSource() == btnNew) {

newSequence();

} else if (e.getSource() == btnCut) {

cutTrack();

} else if (e.getSource() == btnPaste) {

pasteTrack();

} else if (e.getSource() == btnDelete) {

deleteTrack();

} else if (e.getSource() == mnLoad) {

loadFile();

} else if (e.getSource() == mnSave) {

saveFile();

}

}

JFileChooser fc = new JFileChooser();

public void loadFile() {

int returnVal = fc.showOpenDialog(this);

if (returnVal == JFileChooser.APPROVE_OPTION) {

file = fc.getSelectedFile();

try {

System.out.println("Opening: " + file.getCanonicalPath());

sekvents = MidiSystem.getSequence(file);

addSeqenceToTree(sekvents, file.getName());

} catch (Exception ex) {

ex.printStackTrace();

}

} else {

System.out.println("Open command cancelled by user.");

}

}

public void saveFile() {

sekvents = getCurrentSequence(); //millist faili salvestada

if (sekvents == null) return;

int returnVal = fc.showSaveDialog(this);

if (returnVal == JFileChooser.APPROVE_OPTION) {

file = fc.getSelectedFile();

try {

MidiSystem.write(sekvents, 1, new FileOutputStream(file.getCanonicalPath()));

System.out.println("Saved: " + file.getCanonicalPath());

} catch (IOException ex) {

ex.printStackTrace();

}

} else {

System.out.println("Save command cancelled by user.");

}

}

JMenuItem mnUus, mnLoad, mnSave;

public JMenuBar createMenuBar() {

JMenuBar menuBar = new JMenuBar();

JMenu menu = null;

JMenuItem menuItem = null;

menu = new JMenu("Failid");

menuItem = new JMenuItem("Lae..");

menuItem.addActionListener(this);

menu.add(menuItem);

mnLoad = menuItem;

menuItem = new JMenuItem("Salvesta..");

menuItem.addActionListener(this);

menu.add(menuItem);

mnSave = menuItem;

menuBar.add(menu);

return menuBar;

}

public static void main(String[] args) {

// JFrame.setDefaultLookAndFeelDecorated(true);

// Käsk kasutatav alates JDK versioonist 1.4

JFrame frame = new JFrame("KMidi");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

KMidi kodContentPane = new KMidi();

kodContentPane.setOpaque(true);

frame.setJMenuBar(kodContentPane.createMenuBar());

frame.setContentPane(kodContentPane);

frame.pack();

frame.setSize(600, 400);

frame.setVisible(true);

}

}

/**

* Vahend, mille abil hoida objekti koos tema juurde kuuluva sildiga

* Swingi puu tarvis esitataval kujul. Kasutatakse näiteks sekventsi

* hoidmiseks.

*/

class NodeObjectHolder {

public String label = "no name";

public Object userObject = null;

public NodeObjectHolder() {

}

public NodeObjectHolder(String label, Object userObject) {

this.label = label;

this.userObject = userObject;

}

public String toString() {

return label;

}

}

Ülesandeid

Mandoliin

· Joonista ekraanile mandoliin.

· Kasutaja saab määrata joonistatavate krihvide arvu ning kaela laiust.

· Vajutades keele ja krihvi ristumiskohale, kõlab sellele vastav heli.

Kitarri mudel

· Joonista 6-keelse kitarri kaela mudel

· Mängi kitarriakord (E, H, G, D, A, E) (64, 59, 55, 50, 45, 40)

· Peenemal keelel saab määrata, milline krihv on alla vajutatud. Hääl kõlab vastavalt vajutatule

· Krihve saab valida ka teiste keelte puhul ning kuulata tulemust

· Lisaks võib valida täisakorde.

Akordion

· Joonista klaviatuuri ja 36 bassiga akordion.

· Basside ridade ja veergude arvu saab kasutaja määrata. Samuti hiire abil lõõtsa lahti ja kokku vedada.

· Lisaks eelmisele kõlab bassinuppudele vajutades neile vastav heli.

Vilepill

· Joonista vilepill. Pillil on avatud tekstiväljas määratud hulk auke.

· Lisaks eelmisele teeb pillile vajutamisel viimane häält.

· Augule vajutamisel on augud lõpust kuni sinnani avatud. Kõlab sellisele sõrmede paigutusele vastav hääl.

MIDI fail

· Mängi MIDI fail

· Väljasta radade arv

· Salvesta fail tooni jagu kõrgemalt.

· Kopeeri faili muusika iseendale sappa

· Lisa rada, kus viisi mängitakse nihkega (kaanon)