# &MIDI;

## Oversigt

&MIDI;-understøttelsen i &arts; kan gøre et antal forskellige ting. For det første, tillader den kommunikation mellem forskellige dele af programmellet som producerer eller konsumerer &MIDI;-begivenheder. Hvis du for eksempel har en sequencer og en samplingsenhed som begge bruger &arts;, kan &arts; sende &MIDI;-begivenheder fra sequenceren til samplingsenheden.

På den anden side kan &arts; også hjælpe programmer til at vekselvirke med maskinellet. Hvis en programmeldel (for eksempel samplingen) virker sammen med &arts;, kan den desuden tage imod &MIDI;-begivenheder fra et eksternt &MIDI;-keyboard.

Til slut, så udgør &arts; en udmærket modulær synthesizer. Den er konstrueret til at gøre netop dette. Man kan altså bygge instrumenter af små moduler med aRts-byggeren, og derefter bruge instrumenterne til at komponere eller spille musik. Syntese betyder ikke nødvendigtvis kun ren syntese, men der er moduler som kan bruges til at afspille samplinger. På denne måde kan &arts; være både en samplingsenhed eller synthesizer, og eftersom den er fuldstændig modulær, er den meget let at udvide, meget let at eksperimentere med, kraftfuld og fleksibel.

## &MIDI;-håndteringen

Den centrale komponent i &arts; som holder rede på hvilke programmer der er tilsluttet og hvordan midi-begivenheder skal sendes mellem dem er midi-håndteringen. For at se eller påvirke hvad den gør, startes artscontrol. Derefter vælges Vis Vis midihåndtering i menuen.

Til venstre ser man Midi-inddata. Der er alle objekter som producerer &MIDI;-begivenheder på en liste, såsom en ekstern &MIDI;-port som sender data fra et tilsluttet &MIDI;-keyboard, en sequencer som spiller en sang og så videre. Til højre ser man Midi-udskrift. Der er alting som konsumerer &MIDI;-begivenheder på en liste, såsom en simuleret samplingsenhed (programmel), eller den eksterne &MIDI;-port som en hardware-samplingsenhed der er tilsluttet udenfor din maskine. Nye programmer, såsom en sequencer eller lignende, registrerer sig selv, så at listen ændres med tiden.

Du kan tilslutte indgange og udgange hvis du markerer en indgang i listen til venstre og en udgang til højre, og vælger Forbind med knappen nedenfor. Afbryd forbindelse virker på samme måde. Du ser hvad der er tilsluttet som små linjer mellem indgange og udgange, midt i vinduet. Bemærk at du kan tilslutte en indgang til mere end en udgang (og omvendt).

Programmer (såsom sequenceren Brahms) tilføjes af sig selv når de startes og fjernes fra listen når de afsluttes. Men du kan også tilføje nye enheder med menuen Tilføj.

System midi port (OSS)

  Dette laver et nyt &arts;-objekt som kommunikerer med en ekstern midi-port.

  Eftersom eksterne midi-porte både kan sende og modtage data, så tilføjes både en indgang og udgang med dette valg. Med &Linux;, skal du enten have en OSS-driver (eller OSS/Free, som følger med &Linux;-kernen) eller en ALSA-driver installeret for dit lydkort, for at dette skal virke. Du bliver spurgt om enhedens navn. Dette er oftest `/dev/midi` eller `/dev/midi00`.

  Hvis du har mere end en &MIDI;-enhed eller en &MIDI;-tilbagekoblingsenhed installeret, kan der dog være flere valgmuligheder. For at vise information om midi-porte, startes &kcontrolcenter;, og Information Lyd vælges.

aRts syntese midi-uddata

  Dette tilføjer en ny &MIDI;-udgang med et &arts; synteseinstrument. Hvis du vælger menupunktet, kommer en dialog frem, som lader dig angive et instrument. Du kan oprette nye instrumenter med artsbuilder. Alle `.arts`-filer med et navn som begynder med `instrument_` vises her.

## Brug af &arts; & Brahms

I virkeligheden er det rigtig let at komme i gang. Du behøver en version af Brahms som virker med &kde; 2.1, som findes i `kmusic` CVS-modulet. Der er også information om hvordan man får fat på &brahms; på aRts' hjemmeside i afsnittet om download.

Når du har startet programmet, ses det i &MIDI;-håndteringen. Hvis du vil bruge syntese, så tilføj helt enkelt et &MIDI;-instrument med Tilføj aRts syntese midi uddata.

Vælg et instrument (for eksempel organ2). Forbind dem ved brug af knappen Forbind. Derefter kan du begynde at komponere i &brahms;, og resultatet syntetiseres med &arts;.

Det er oftest en god ide at have &artscontrol;-vinduet åbent, og se at lydstyrken ikke er for høj (lydkvaliteten bliver dårligere når bjælkerne når den øvre grænse). Nu kan du begynde at skrive en ny &arts; demo, og når du er klar kan du få den publiceret på aRts-project.org ;-).

## midisend

`midisend` er et lille program som lader dig sende &MIDI;-begivenheder fra skallen. Det registreres som en klient ligesom alle andre programmer. Den enkleste måde at bruge det er at skrive

    &percnt; midisend -f /dev/midi00

hvilket opnår cirka det samme som at tilføje en &MIDI;-port til &artscontrol;. (Ikke helt, fordi `midisend` kun sender begivenheder). Forskellen er at det er for eksempel er let at starte `midisend` på forskellige computere (og på den måde bruge netværkstransparens).

Det er også muligt at lade `midisend` sende data fra `stdin`, hvilket du kan bruge til at sende data fra programmer som ikke understøtter &arts;, sådan her:

    &percnt; program_som_sender_MIDI_begivenheder_til_standarduddata | midisend -f -

## Opret instrumenter

Den måde &arts; udfører midi-syntese er følgende: Du har strukturer som har et antal indgange, hvor de henter frekvensen, hastigheden (lydstyrke) og en parameter som angiver om tasten stadigvæk er trykket ned. Strukturen skal nu syntetisere nøjagtigt den tone med den lydstyrke, og reagere på parameteren pressed (hvor pressed = 1 betyder at brugeren holder tasten nede og pressed = 0 betyder at brugeren har sluppet tasten).

Når &MIDI;-begivenheder ankommer, laver &arts; nye strukturer for tonerne efter behov, angiver parametrene, og rydder dem væk når de er færdige.

For at oprette og bruge en sådan struktur, skal du gøre følgende:

- For at komme i gang er den behageligste måde at åbne `template_Instrument.arts` i &arts-builder;.

  Dette kan opnås ved at bruge Fil Åbn eksempel... og vælge template_Instrument i fildialogen. Dette laver en tom struktur med de nødvendige parametre, som du kun behøver udfylde.

- For at håndtere parameteren "pressed", er det praktisk at bruge Synth&lowbar;ENVELOPE&lowbar;ADSR, eller hvis en wav-fil med tromme spilles, så spil den blot alligevel og ignorér parameteren.

- Strukturen skal indikere hvornår den ikke behøves længere med uddata done. Hvis done er 1, antager &arts; at strukturen kan slettes. Praktisk nok så sørger ADSR-envelopen for en parameter som angiver når den er færdig, så du behøver kun forbinde den til done-udgangen for strukturen.

- Du bør omdøbe din struktur til et navn som begynder med `instrument_`, såsom `instrument_piano.arts` - du bør gemme filen under samme navn i mappen `$`HOME`/arts/structures` (hvor artsbuilder normalt gemmer filer).

- Til sidst, når du har gemt den, kan du bruge den med &artscontrol; i &MIDI;-håndteringen.

- Åh, og din struktur skal naturligvis afspille lyddata som den laver via venstre og højre udgang for strukturen, som siden afspilles med lydhåndteringen (du kan se dette i &artscontrol;), så du til slut kan høre lyden (eller efterbehandle den med lydeffekter).

En god måde at lære sig hvordan man laver instrumenter er at åbne et eksisterende instrument med Fil Åbn eksempel og se hvordan det virker ;)

## Instrumentkort

Instrumentkort er instrumenter som opfører sig forskelligt afhængig af tonehøjden, programmet, kanalen eller hastigheden. Man kan for eksempel oprette et piano med fem oktaver, og bruge en sampling for hver oktav (med tonehøjden forskudt tilsvarende). Dette lyder meget bedre end kun at bruge en sampling.

Man kan også bygge et trommekort, som spiller en særlig trommesampling for hver tast.

Til sidst er det meget nyttigt hvis man kombinerer helt forskellige lyde i et instrumentkort for forskellige programmer. På denne måde kan man bruge sin sequencer, eksterne keyboard eller en anden &MIDI;-kilde til at skifte mellem lyde uden at behøve at manipulere &arts; under arbejdets gang.

Et godt eksempel på dette er `arts_all`, som helt enkelt kombinerer alle instrumenter som levereres med &arts; i et kort. På denne måde behøver man kun angive at dette instrument skal bruges en gang i &artscontrol;, og derefter kan man komponere en hel sang i en sequencer uden overhovedet at bryde sig om &arts;. Brug for en anden lyd? Ændr helt enkelt programmet i sequenceren, og &arts; sørger for en ny lyd.

Oprettelse af sådanne kort er ganske ligetil. Man behøver kun at oprette en tekstfil, og skrive regler som ser sådan her ud:

    ON [ betingelser ...] DO structure=en_struktur.arts

Betingelserne kan være en eller flere af følgende:

`pitch`

  Tonehøjden som spilles. Man bruger dette hvis man vil opdele instrumentet afhængig af tonhøjde. I vort oprindelige eksempel, skulle et piano som bruger forskellige samplinger for forskellige oktaver bruge dette som betingelser. Man kan angive en enkel tonehøjde, såsom ``pitch`=`62`` eller et interval af tonehøjder, såsom ``pitch`=`60`-`72``. De mulige tonehøjder går mellem `0` og `127`.

`program`

  Programmet som er aktivt på kanalen som tonen afspilles i. Oftest lader sequenceren dig vælge instrument via programindstillingen. Enkle programmer eller intervaller er tilladte, dvs. ``program`=`3`` eller ``program`=`3`-`6``. Mulige programmer går mellem `0` og `127`.

`channel`

  Kanalen som tonen sendes på. Enkle kanaler eller intervaller er tilladte, dvs. ``channel`=`0`` eller ``channel`=`0`-`8``. Mulige kanaler går mellem `0` og `15`.

`velocity`

  Hastigheden (lydstyrken) som tonen har. Enkle hastigheder (hvem skulle ville bruge det?) eller intervaller er tilladte, dvs. ``velocity`=`127`` eller ``velocity`=`64`-`127``. Mulige hastigheder går mellem `0` og `127`.

Et fuldstændigt eksempel for et kort kan være (dette kommer fra den nuværende `instrument_arts_all.arts-map`):

    ON program=0 DO structure=instrument_tri.arts
    ON program=1 DO structure=instrument_organ2.arts
    ON program=2 DO structure=instrument_slide1.arts
    ON program=3 DO structure=instrument_square.arts
    ON program=4 DO structure=instrument_neworgan.arts
    ON program=5 DO structure=instrument_nokind.arts
    ON program=6 DO structure=instrument_full_square.arts
    ON program=7 DO structure=instrument_simple_sin.arts
    ON program=8 DO structure=instrument_simple_square.arts
    ON program=9 DO structure=instrument_simple_tri.arts
    ON program=10 DO structure=instrument_slide.arts
    ON program=11 pitch=60 DO structure=instrument_deepdrum.arts
    ON program=11 pitch=61 DO structure=instrument_chirpdrum.arts

Som du ser, vælges strukturen afhængig af programmet. For program 11, ses et trommekort (med to indgange), som vil spille en deepdrum med C-5 (tonehøjde = 60), og en chirpdrum med C#5 (tonehøjde = 61).

For at kortfiler automatisk skal ses i &artscontrol; som et valg for instrumenterne, skal de hedde `instrument_noget.arts-map` og enten være i din hjemmemappe i `$`HOME`/arts/structures`, eller i &kde;-mappen i `$`KDEDIR`/share/apps/artsbuilder/examples`. Strukturer som bruges af kortene kan enten angives med en absolut søgesti, eller relativt til mappen som kortfilen findes i.

Udvidelse af arts_all map eller til og med at lave et fuldstændigt generelt &MIDI;-kort for &arts; er en god idé for at gøre &arts; lettere at bruge direkte som det er. Overvej gerne at bidrage med interessante instrumenter som du laver, så de kan inkluderes i fremtidige udgaver af &arts;.