# Fremtidigt arbejde

Dette afsnit beskriver en del af det pågående arbejde med &arts;. Udviklingen går hurtigt fremad, så denne information kan være forældet. Du bør kontrollere listefilen TODO og arkiverne for e-postlisterne for at holde styr på hvilke nye funktioner der er planlagt. Deltag gerne i ny konstruktion og implementation.

Dette er et udkast som forsøger at give dig en oversigt over hvordan nye teknologier vil integreres i &arts;. Det dækker følgende:

- Hvordan grænseflader virker.

- Afkodere - afkodning af mp3 eller wav-strømme til en form som gør at de kan bruges som data.

- Video.

- Trådning.

- Synkronisering.

- Dynamisk udvidelse/maskering.

- Dynamisk sammensætning.

- &GUI;

- &MIDI;

Dette er pågående arbejde. Det bør dog kunne give grundlaget hvis du vil kigge på ny teknologi i &arts;. Det bør give dig en almen idé om hvordan disse problemer vil blive angrebet. Korrigér gerne alt du ser her.

Ting som vil bruge &arts;-teknologi (så vær venlig og koordinér anstrengelserne):

- K-telefon (tale via IP)

- &noatun; (videoafspiller / lydafspiller)

- &artscontrol; (styreprogram for lydserveren, og for målere)

- Brahms (musiksequencer)

- Kaiman (&kde;2 medieafspiller - kmedia2-kompliant)

- mpglib/kmpg (mpg lyd- og videoafspilningsteknologi)

- SDL (direkte medialag for spil, som endnu ikke er påbegyndt men som kan være behageligt)

- Elektriske ører (ophavsmanden kontaktede mig - status ukendt)

## Hvordan grænseflader virker

&MCOP;-grænsefladen er grundlaget for &arts;-begrebet. De er det netværkstransparente ækvivalente til C++ klasser. Så snart det er muligt bør du indrette din konstruktion mod grænseflader. En grænseflade består af fire dele:

- Synkrone strømme

- Asynkrone strømme

- Metoder

- Egenskaber

Disse kan blandes på en hvilken som helst måde du vil. Nye teknologier bør defineres ved hjælp af grænseflader. Læs afsnittene om asynkrone strømme og synkrone strømme, samt KMedia2-grænsefladen, som er gode eksempler på hvordan sådanne ting virker.

Grænseflader specificeres i `.idl`-kode og køres gennem `mcopidl`-oversætteren. Man afleder `Grænsefladensnavn_impl` klassen for at implementere dem, og bruger `REGISTER_IMPLEMENTATION (Grænsefladensnavn_impl)` til at indsætte en objektimplementering i &MCOP;'s objektsystem.

## Codec'er, dataafkodning

Kmedia2-grænsefladen lader dig se bort fra at wav-filer, mp3-filer eller hvad som helst består af datastrømme. I stedet implementerer du kun metoder for at spille dem.

På den måde kan du skrive en bølgeformsladningsrutine på en måde så du kan spille bølgeformsfiler (som PlayObject), men ingen anden kan bruge din kode.

Asynkrone strømme ville være alternativet. Man definerer en grænseflade som tillader at datablokke sendes ind, og hentes ud. Dette ser sådan her ud i &MCOP;:

    interface Codec {
      in async byte stream indata;
      out async byte stream outdata;
    };

Afkodere kan naturligvis også angive egenskaber for at udsende yderligere data, som formatinformation.

    interface ByteAudioCodec {
      in async byte stream indata;
      out async byte stream outdata;
      readonly attribute samplingRate, bits, channels;
    };

Denne ByteAudioCodec kan for eksempel forbindes til et ByteStreamToAudio-objekt, for at oprette rigtigt flydende lyd.

Andre typer af afkodere kan naturligvis involvere at sende videodata direkte ud, som

    interface VideoCodec {
      in async byte stream indata;
      out video stream outdata;      /* note: video streams do not exist yet */
    };

Sandsynligvis bør et afkodningsbegreb bruges i stedet for måden du ved hvordan det spilles med det gør jeg ikke som for eksempel WavPlayObject bruger for øjeblikket. Nogen skal dog sætte sig ned og eksperimentere lidt inden en programmeringsgrænseflade kan defineres.

## Video

Min idé er at sørge for video som asynkrone strømme for en indbygget &MCOP;-datatype som indeholder billeder. Denne datatype er ikke lavet endnu. Ved at gøre dette, kan indstiksprogrammer som håndterer video kobles sammen på samme måde som lydindstiksprogrammer.

Der er nogle ting som det er vigtigt ikke at udelade:

- Der er RGB og YUV farverum.

- Formatet bør markeres i strømmen på en måde.

- Synkronisering er vigtig.

Min idé er at lade muligheden for at ændre implementeringen af `VideoFrame`-klassen være åben, så den kan opbevare ting i et delt hukommelsessegment. Ved at gøre dette kan til og med videostrømme mellem forskellige processer blive mulige uden alt for store problemer.

For video er den almindelige situation dog at alle ting er i samme proces, fra afkodningen til visningen.

Jeg har lavet en prototypeimplementering af videostrømme, som kan hentes herfra. Dette skal integreres med &MCOP; efter nogle eksperimenter.

En visningskomponent som understøtter XMITSHM (med RGB og YUV) bør der sørges for. Martin Vogt fortalte mig at han arbejder på en sådan.

## Trådning

For øjeblikket er &MCOP; helt og holdent en eneste tråd. For video kan vi måske ikke længere komme udenom tråde. O.k. Der er nogle ting som skal håndteres med forsigtighed:

- SmartWrappers - de er ikke trådsikre på grund af usikker referenceregning og lignende.

- Afsenderen / I/O - heller ikke trådsikre.

Hvad jeg i alle tilfælde kan tænke mig er at gøre udvalgte moduler trådsikre, både for synkrone og asynkrone strømme. På denne måde kan man skemalægge signalstrømmen på to eller flere processorer, med et flowsystem som kender til tråde. Dette burde også hjælpe en hel del med lyd med multiprocessorer.

Hvordan det ville virke:

- Flowsystemet bestemmer hvilke moduler der skal beregne hvad, dvs:

  - video frames (with process_indata method)

  - synkrone lydstrømme (calculateBlock)

  - andre asynkrone strømme, i hovedsagen datastrømme

- Modulerne kan beregne disse ting i egne tråde. For lyd giver det mening at genbruge tråde (f.eks. håndtere den med fire tråde hvis der er fire processorer, også selvom 100 moduler kører). For video- og datakompression, kan det være bekvemmere at have en blokerende implementering i en egen tråd, som synkroniseres med resten af &MCOP; med flowsystemet.

- Moduler må ikke bruge &MCOP;-funktioner (som fjernkaldes) mens trådede operationer er igang.

## Synkronisering

Video og &MIDI; (og lyd) kan kræve synkronisering. I grunden er dette tidsstempler. Idéen jeg har er at tilknytte tidsstempler til de asynkrone strømme, ved at tilføje et tidsstempel til hver pakke. Hvis man sender to videobilleder, gøres det helt enkelt som to pakker (de er store alligevel), så man kan have to forskellige tidsstempler.

Lyd skal have underforståede tidsstempler, eftersom det er synkront.

## Dynamisk sammensætning

Det bør være muligt at sige: En effekt FX består af disse enkle moduler. FX bør se ud som en normal &MCOP;-modul (se maskering), men i virkeligheden bestå af andre moduler.

Dette kræves for &arts-builder;.

## &GUI;

Alle komponenter i den grafiske grænseflade vil være &MCOP;-moduler. De bør have egenskaber som størrelse, etiket, farve, ... En RAD-bygger (&arts-builder;) bør kunne sammensætte dem visuelt.

Den grafiske grænseflade bør det være muligt at gemme ved at gemme egenskaberne.

## &MIDI;

&MIDI;-tingene vil blive implementeret som asynkrone strømme. Der er to alternativer, en er at bruge normale &MCOP;-strukturer til at definere typerne og den anden er at introducere yderligere egne typer.

Jeg tror at normale strukturer vil slå til, dvs noget som:

    struct MidiEvent {
      byte b1,b2,b3;
      sequence<byte> sysex;
    }

Asynkrone strømme bør understøtte egne strømningstyper.