v0.1 klaar!

Een eerste alfaversie van de applicatie is klaar. Zoals in de planning beschreven is de step sequencer afgerond: mogelijkheid tot selecteren van een instrument uit een beperkte verzameling, plaatsen van een instrument op de sequencer, wisselen van plaats op de sequencer, eenvoudige start/stop-functionaliteit, synchronisatie van GUI met muziek. De step sequencer is niet volledig tot in detail grafisch uitgewerkt, maar de interface om met Ableton te communiceren is wel volledig klaar. Dit omdat de grafische interface in een volgende versie waarschijnlijk gebruik gaat maken van de DiamondSpin-library die in zijn laatste versie volledig werkt via TUIO-berichten (reeds getest!) en daardoor in feite grotendeels omgegooid gaat worden. Nu is het de bedoeling deze implementatie kort te evalueren (evt. na testsessie op tabletop zelf?). In een volgende stap worden de effecten en de algemene instellingen (volume per instrument, algemeen volume, ...) aangepakt. De interface Java-Ableton zal hierbij vrij gelijkaardig zijn aan die om noten te sturen: MIDI Control Change message sturen naar Ableton waarbij elke message vooraf gekoppeld werd aan een bepaalde parameter (ook al getest).

Verslag meeting 22/2

aanwezigen: Bram Vandeputte, Nik Corthaut, Jef Hermans
onderwerpen:
* voorstelling van huidige applicatie + uitleg over gebruikte implementatie
* verzenden van MIDI-berichten: het simuleren van de sequencer door Thread.sleep() te gebruiken is zoals geweten geen goede oplossing, hier moet de komende week een oplossing voor gezocht worden in een kleine "vergelijkende studie". Er zijn een aantal mogelijkheden: Max (for Live) gebruiken, lightweight Java application die sequencerfunctie op zich neemt en gebruik maken van Ableton voor de effecten, ... Elke keuze zal voor- en nadelen hebben en ook gevolgen meebrengen voor de applicatie.
* volgende meeting: 1/3 10u

Real Time Sequencer

Het probleem van het gelijkmatig afspelen van MIDI-berichten lijkt dan toch een eenvoudige oplossing te hebben. Sinds JDK 1.5 beschikt Java over een Real Time Sequencer die ingesteld staat als default sequencer en simpelweg opgevraagd kan worden via MidiSystem.getSequencer(false). Deze sequencer is real time en geeft dus onmiddellijk gevolg aan verandering in MIDI-events die opgeslagen zitten in een sequence-object, precies wat we willen. De klok van de sequencer kan ook naar wens ingesteld worden. Ideaal zou zijn dat Ableton de masterklok heeft en dat de Java-sequencer deze klok als slave volgt, maar de huidige opstelling (Java-sequencer is master en gebruikte interne klok) is eenvoudiger te implementeren (de ideale implementatie vereist hoe dan ook Max for Live) en geeft ook prima timing resultaten. De visualisatie (GUI) zou nu ook gesynchroniseerd moeten kunnen worden met de sequencer: ofwel via een listener die luistert naar MetaMessages ofwel direct via de klok van de sequencer (door de GUI op één of andere manier in te stellen als slave van de sequencer, moet nog nagekeken worden of dit wel mogelijk is).

Java, MIDI & Ableton Live 8.1

Benodigdheden:
* virtual midi port (LoopBe1)
* Java MIDI device dat MIDI berichten kan zenden (ontvangen is niet nodig)
(* Max for Live (M4L) patch die muzikale output mogelijk maakt adhv ontvangen MIDI-bericht)
* Ableton Live 8.1

Om MIDI-berichten te kunnen zenden van Java naar Ableton is er een virtuele midi-poort nodig die in feite als kabel dient. In Java is het dan mogelijk om via MidiSystem het MidiDevice op te vragen dat overeenkomt met de virtuele poort. Dit device kan een ShortMessage doorgeven aan Ableton dat per instrument kan instellen op welk kanaal en welke poort het moet luisteren. Het kanaal dat opgegeven in de ShortMessage komt NIET overeen met het kanaal in Ableton! (setMessage(int command, int channel, int data1, int data2))
Ableton: Ch. 1 -> Java int: 31 of 63 of 127 ...
Ch. 2 -> Java int: 1
Ch. 3 -> 2
...
Aangezien er 16 MIDI-kanalen zijn is het dus mogelijk om op deze manier 16 verschillende instrumenten aan te sturen. Weliswaar op een beperkte manier omdat ik er nog niet in geslaagd ben om Midi events te sturen naar Ableton die niet alleen info over noten bevatten maar ook info over het tempo. Deze manier zou ideaal zijn en wordt daarom nog verder onderzocht. In de huidige testapplicatie wordt voorlopig nog gewerkt met een Thread.sleep(long) om het tempoprobleem op te lossen.

Verslag meeting 15/2

aanwezigen: Bram Vandeputte, Nik Corthaut, Jef Hermans
onderwerpen:
* bespreking problemen met processing: Het feit dat vensters niet gedraaid kunnen worden is geen probleem voor een eerste 0.1 versie van de applicatie. Het belangrijkste is om zo snel mogelijk tot een eerste werkende versie te komen die alle aspecten (touchinput - muzikale output) in zekere zin bevat. Het multi-user aspect mag hierbij even achterwege gelaten worden.
Voor het probleem met het werken met meerdere frames moet op het net zeker wel een oplossing te vinden zijn. Maar er hoeft ook niet noodzakelijk met frames gewerkt worden...
* bespreking van het muzikale aspect van de applicatie: Hierbij werd de vraag gesteld of er al onderzocht is hoe de link gelegd kan worden tussen Java en de software die voor de muzikale output zorgt (bv. Ableton Live). Java heeft een uitgebreide MIDI-bibliotheek en zou eventueel MIDI-berichten kunnen sturen om instrumenten aan te sturen. Voorlopig is dit nog niet grondig onderzocht, maar hier wordt uiteraard deze week nog werk van gemaakt.
* volgende meeting: 22/2 10u: op dat moment zou er meer duidelijkheid moeten zijn over hoe Java communiceert met de muzieksoftware adhv een kleine testapplicatie

Planning tweede semester

planning: html

TODO tegen 1 maart:
1) aanmaken van instrumentenframe waar verschillende instrumenten adhv cirkels met kleuren of figuren gekozen kunnen worden (nog uitzoeken hoe dit kan in processing) -> momenteel wordt uitgezocht of het de moeite is om een uitgebreide implementatie te maken in Processing of direct gebruik te maken van de vernieuwde DiamondSpin-library
2) synchronisatie tussen GUI en muziek -> done
3) koppeling van instrumenten aan objecten (bv. cirkels met kleuren of figuren) -> done
4) afwerken (GUI) step sequencer -> done
5) nadenken over algemene software-architectuur (gui-muziek-tuio) -> muziekgedeelte is klaar

DiamondSpin

paper: DiamondSpin: An Extensible Toolkit for Around-the-Table Interaction
youtube video
Wanneer meerdere personen rond een tafel moeten samenwerken aan eenzelfde project of document, in dit geval het maken van een muziekstuk, moet de grafische interface deze face-to-face samenwerking ondersteunen. Het probleem hierbij is dat noch processing noch Java AWT of Swing hier mogelijkheden voor bieden. Met de DiamondSpin-toolkit probeert men die mogelijkheden binnen Java uit te breiden naar een tabletopomgeving waar meerdere personen met verschillende oriëntaties ten opzichte van de tafel samenkomen. Het wordt dus mogelijk om rechthoekige, octagonale of circulaire tabletop layouts te maken, waarbij de plaatsing van de documenten niet langer gericht zijn naar 1 bepaalde persoon. Om de voordelen van around-the-table interactie ten volle te benutten is het dus absoluut noodzakelijk om een toolkit zoals DiamondSpin te gebruiken.
De grote fundamentele uitdaging die de ontwikkelaars van DiamondSpin aangingen is het afstappen van de single-user rechthoekige interface en trachten een multi-user tabletop interface te maken die gelijktijdige interactie mogelijk maakt. Hiervoor wordt een nieuwe architectuur bedacht die leidde tot de DiamondSpin toolkit.

DiamondSpin architectuur
DiamondSpin bestaat grotendeels uit 2 componenten:
1) een engine die verantwoordelijk is voor de omzetting tussen poolcoördinaten en Carthesiaanse coördinaten. TouchEvents of MouseEvents komen typisch binnen als grafische 2D-coördinaten en worden omgezet naar poolcoördinaten omdat DiamondSpin intern met deze representatie werkt. Men kan dan gemakkelijk inzien dat er 3 vrijheidsgraden zijn voor een element van de GUI: de afstand tot de oorsprong, de hoek ten opzichte van de oorsprong en de oriëntatie ten opzichte van het eigen middelpunt (of een punt waar dat element geselecteerd wordt).
2) een engine die instaat voor multi-layer multi-thread display management. De verschillende elementen van de grafische interface kunnen deel uitmaken van verschillende layers. Layer 0 bevat bv. de elementen die ongevoelig zijn voor rotatie van de tabletop. Layer 1 bevat typisch elementen die passief zijn, maar actief kunnen gemaakt worden door ze bv. te selecteren (Layer 2). Ook zorgt deze engine voor het management van meerdere threads. Er is een thread die verantwoordelijk is voor input handling (aanpassing van eigenschappen van interface-elementen) en een andere voor de repaint van de elementen.

DiamondSpin API
In deze sectie legt men de belangrijkste klassen kort uit en zegt men hoe een kleine applicatie bestaande uit een DSFrame kan worden gemaakt. DSContainer (in de nieuwste versie heet deze klasse DSTabletopPane) en DSView zijn hierbij de belangrijkste klassen. DSContainer biedt methodes aan voor input handling, repainting/refreshing, documentoriëntatie, ... DSView kan gebruikt worden om meerdere views te creëren op dezelfde tabletop: een workspace per gebruiker of een gedeelde workspace voor groepen van gebruikers. DSFrame, DSPanelen DSWindow zijn klassen die de bestaande klassen uit Java Swing uitbreiden en geschikt maken voor een tabletopomgeving.

Hierna vermeldt men nog enkele voorbeelden van applicaties die steunen op DiamondSpin.

Problemen met processing

Momenteel probeer ik elk onderdeel van mijn ontwerp beetje bij beetje uit te werken in processing om zo een eerste volledige iteratie af te werken en zo snel mogelijk tot een werkend programma te komen. Hierbij zijn toch al enkele problemen en beperkingen ivm processing opgedoken:
* Een probleem met de vensters is de oriëntatie. Dit geldt niet alleen voor processing, maar ook voor bv. Java AWT. Processing en Java AWT zijn niet geschikt voor GUI's waar mensen het scherm bekijken vanuit verschillende standpunten aangezien er niet dadelijk een mogelijkheid is om frames te draaien. Er is een Java toolkit die hier een oplossing voor zou bieden: DiamondSpin.
* Processing kan precies moeilijk overweg met meer dan 1 frame tegelijkertijd. Er kunnen wel meerdere frames getoond worden, maar als er één wordt afgesloten, wordt het programma beëindigd.

Eerste kleine testapplicatie

Om de tabletop en de tracker (Community Core Vision) te testen maakte ik een kleine java applet: de verschillende bollen kunnen versleept worden over het scherm of kunnen verwijderd worden door ze 1 keer aan te raken.