Haskell musiziert

Haskell musiziert
Haskell musiziert
Henning Thielemann
2014-06-27
Haskell musiziert
Übersicht
1 Übersicht
2 Signalverarbeitung
3 Musik
4 Abschluss
Haskell musiziert
Übersicht
Wie sind Computer an Musik beteiligt?
Signal: zeitlicher Verlauf von Membranauslenkungen
Erzeugung: Instrumente, Effekte, Sprache
Verarbeitung: Verfremden, Sprachverzerrung, Entrauschen,
Klicks entfernen, Brummen entfernen, Manipulation von
Tempo und Tonhöhe
Analyse: Gleichstromanteil, Lautstärkeverlauf,
Frequenzanalyse, Spracherkennung
Kompression
Musik: zeitliche Anordnung von Ereignissen
Erzeugung: Zufallsmusik, Begleitautomatik
Analyse: Takt, Tonart
Haskell musiziert
Signalverarbeitung
1 Übersicht
2 Signalverarbeitung
3 Musik
4 Abschluss
Haskell musiziert
Signalverarbeitung
Grundlagen
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Signalverarbeitung
Grundlagen
Was hören wir?
Geräusch:
zeitabhängige Auslenkung einer Membran
mathematisch: Auslenkung ist Funktion der Zeit
Haskell musiziert
Signalverarbeitung
Grundlagen
Klangeigenschaft: Tonhöhe
tiefer Ton
hoher Ton
Haskell musiziert
Signalverarbeitung
Grundlagen
Klangeigenschaft: Lautstärke
leise
laut
Haskell musiziert
Signalverarbeitung
Grundlagen
Klangeigenschaft: Klangfarbe
dumpf
scharf
Haskell musiziert
Signalverarbeitung
Grundlagen
Keine Klangeigenschaft: Phasenlage
0◦
90◦
Haskell musiziert
Signalverarbeitung
Grundlagen
Wie hören wir?
Ohr zerlegt Signal in reine Sinus-Schwingungen verschiedener
Frequenzen
Einzelne Schwingungen:
Mischung:
Haskell musiziert
Signalverarbeitung
Grundlagen
Amplitudenmodulation vs. Frequenzmischung
Heisenbergsche Unschärferelation:
man kann Frequenz und Zeitpunkt eines Tones
nicht beliebig genau angeben
Grund: Definition von Ton“
”
es gibt keine momentane Frequenzzusammensetzung
Lautstärkeänderung kann prinzipiell nicht von
Tonüberlagerung unterschieden werden
Haskell musiziert
Signalverarbeitung
Grundlagen
Modulation
statischer Ton: klingt künstlich
Frequenzmodulation: Vibrato-Effekt
Überlagerung mehrerer verschieden modulierter Töne: Chorus
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Einfacher Klang
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Signalfluss
exponential
oscillator
envelope
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Signalalgorithmus
imperativ – maschinennah
expo := exponential 0.1
osci := oscillator 440
ping := envelope expo osci
funktional – Umsetzung von Flussdiagramm
ping =
envelope
( exponential 0.1)
( oscillator 440)
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Rechnen mit Signalen
Addition =
b Mischen
Multiplikation =
b Lautstärkemodulation (envelope)
Rechengesetze
a+b =b+a
Kommutativität
(a + b) + c = a + (b + c)
Assoziativität
h · (a + b) = h · a + h · b
Distributivität
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Assampler
1999 für Commodore Amiga
Zusammenstellen von Klangverarbeitungsalgorithmen:
graphisch oder per Formular
Bedarfsauswertung in Blöcken
physikalische Einheiten
Beispiel: Ping
Sinuston, Exponentialkurve, Verstärker
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Assampler - Probleme
Aufteilen von Signalstrom (Gabelung)
Rückkopplung, Latenz
Abgleich von Abtastraten und Amplitude
Umgang mit Zufallszahlen, kohärentes Rauschen
flexiblere Automatisierung (Beispiel: Mehrbandvocoder)
Übersichtlichkeit: Modularisierung, Dokumentation
Musikarrangement
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Haskell: Laziness
type Signal = []
Beispiel Mischen: c = zipWith (+) a b
zum Berechnen des ersten Wertes von c
benötigt man nur die ersten Werte von a und b
Bedarfsauswertung (lazy evaluation) erlaubt
Programmierung in Reihenfolge von Signalabhängigkeit
Verarbeitung in zeitlicher Reihenfolge (streaming)
Gabelungen (sharing)
let x = sound param in zipWith (+) x (delay x)
Bedarfsauswertung erlaubt Rückkopplung
let y = x + delay y in y
fix (\y -> x + delay y)
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Haskell
Zufallszahlen: Monade
Analogie: Typenabgleich (type inference)
und Abstimmung von Abtastraten
Compiler für Haskell oder LLVM-JIT
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Komplexes Beispiel: Tausend Sterne sind ein Dom
Gitarre: Anfang wegwerfen, Verzerrer, Hall, Verstärken
Begleitung: am Anfang auffüllen, mit Gitarre Mischen
Synthesizer: MIDI→Audiosignal, vieles mehr
Hall: Überlagerung vieler Echos
Synthesizer-Instrument:
Anschlagstärke, Hüllkurve, Tongenerator, . . .
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Fazit: Haskell vs. Signalflussdiagramm
Haskell kann
Übersetzung von Signalflussdiagrammen
+ nicht-kausale Operationen
+ Wiederholung von Operationen
+ Unterprogramme
+ diskrete Datenströme (MIDI-Kommandos)
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Signalverarbeitung: Hörbeispiele
Haskell
Fliege
Glasbruch
Rauschen mit Tschebyscheff-Filter
Blubberblasen
Wind
Bass mit Filter
SuperCollider evtl.
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Bedarfsauswertung: Beispiele
Laziness = Nichtstriktheit + Pufferung
let str = ’a’:str in str
let prg = 0 : map succ prg in prg
Fibonacci-Folge
Sinuskurve iterativ berechnen
Differentialgleichung – expliziter Euler
Primzahlen-Folge
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Bedarfsauswertung: Schwingungsgleichung
y 00 + p · y 0 + q · y = 0
Lösung:
y : R→C
y = t 7→ e λ·t
Einsetzen:
t 7→ λ2 · e λ·t + p · λ · e λ·t + q · e λ·t = 0
λ2 + p · λ + q = 0
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
Übung
Selber programmieren:
Blubberblasen: Sinus, frequenzmoduliert mit Sägezahn
Fliege: Sägezahn, frequenzmoduliert mit rosa Rauschen
Technik:
GHC
Pakete bytestring oder storablevector
SoX, WAVE oder hsndfile-storablevector
Haskell musiziert
Signalverarbeitung
Signalalgorithmen
noch mehr Übung
Oscillator
Blubbern
Exponential
Ping
Rauschen
Tiefpass erster Ordnung
Komplexer Tiefpass erster Ordnung
Echo/Kammfilter
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Signalparameter - maschinennah
digitale Hardware-Synthesizer, CSound, SuperCollider:
feste Abtastraten für
hörbare Signale
Steuersignale
Notenwiedergabe
untypisiert
keine physikalischen Einheiten
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Signalparameter - physikalisch
Ziel: Annäherung an analoge Daten
Synthesizer-Bibliothek für Haskell:
frei wählbare Abtastraten, automatischer Abgleich
statisch typisiert
Typen für Abtastwerte:
kontinuierliche Werte – Double
Wertetupel für Stereophonie – (Double,Double)
An/Aus-Steuerung – Bool
physikalische Einheiten
Modellierung natürlicher Vorgänge
Nachbau Analogsynthesizer
höhere Programmiersicherheit
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Physikalische Einheiten
Abtastrate 44100 Hz – 44100 Abtastwerte pro Sekunde
Amplitude 1 V – Spannungsbereich -1 V . . . 1 V
441-Hz-Ton bei Abtastrate 44100 Hz:
100 Abtastwerte pro Schwingung
Ebenfalls möglich:
Abtastrate 1000/m und Schwingung mit Frequenz 10/m
Nicht möglich:
Abtastrate 1000/m und Schwingung mit Frequenz 10 Hz
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Vorgehensweise
Am Ende jeder Rechnung
muss maschinennaher Parameter stehen
maschinennahe Parameter einheitenlos
Alternative: Spezielle Einheiten für Maschinenparameter
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Physikalische Einheiten: dynamisch geprüft
data PhysicalSignal t t ’ y y ’ yv =
PhysicalSignal {
sampleRate :: t ’ ,
amplitude :: y ’ ,
body :: [ yv ]
}
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Physikalische Einheiten: dynamisch geprüft
Beispiele:
Monosignal ohne Einheiten
PhysicalSignal Double Double
Double Double Double
Stereosignal mit Einheiten
PhysicalSignal Double (SI Double
Double)
Double (SI Double
Double) (Stereo Double
Double)
Signal mit Festkommaabtastwerten
PhysicalSignal Double Double
Double Double FixedPoint
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Probleme
Beispiel: mix x y
unterschiedliche Abtastratenwerte und -einheiten
unterschiedliche Amplitudenwerte und -einheiten
Konflikte zur Laufzeit getestet
Ziel: Lasse Typprüfer testen
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Lösungen
Abtastrate müssen meistens gleich sein
Abtastrate schwer nachträglich zu ändern
Interpolation, Qualitätsverlust
besser: gleiche Abtastrate vorher sicherstellen
Zusammenhangskomponenten mit gleicher Abtastrate
Amplituden können ruhig verschieden sein
Amplituden leicht nachträglich zu ändern
nur kleine Rundungsfehler
am besten: Amplituden anpassen, wenn nötig
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Abtastratenkontext
newtype Rate s t t ’ = Rate t ’
data ContextSignal s y y ’ yv =
ContextSignal {
amplitude :: y ’ ,
body :: [ yv ]
}
sound ::
Reader ( Rate s t t ’)
( ContextSignal s y y ’ yv )
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Mixer im Wandel der Zeit
vorher
mix ::
PhysicalSignal t t ’ y y ’ yv ->
PhysicalSignal t t ’ y y ’ yv ->
PhysicalSignal t t ’ y y ’ yv
nachher
mix ::
Reader ( Rate s t t ’)
( ContextSignal s y y ’ yv ->
ContextSignal s y y ’ yv ->
ContextSignal s y y ’ yv )
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Abtastraten
Reader wird mit Applicative-Kombinatoren verwendet
Bindung an den Kontext lösen
render ::
Reader ( Rate s t t ’)
( ContextSignal s y y ’ yv ->
PhysicalSignal t t ’ y y ’ yv )
aus diesem Funktor kann man nur ausbrechen mit
run ::
( forall s . Reader ( Rate s t t ’) a ) ->
t ’ -> a
abgeschaut bei ST-Monad
Haskell musiziert
Signalverarbeitung
Sicherheit: Physikalische Einheiten
Einheiten
newtype Dimensio nalNum ber d a =
DimensionalNumbe r a
d kann sein: (Einheiten in Typen für arme Leute)
Scalar
Time
Frequency (Recip Time)
Voltage
...
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Speicherung der Abtastwerte
Liste
Chunky StorableVector
Generator
Prozesse
LLVM
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Datenstruktur Liste
Vorteile
Bedarfsauswertung pro Element
Gabelungen mit Pufferung
beliebige Rückkopplung
jeder Haskell-Datentyp als Element möglich, auch Funktionen
→ ideal für Signalverarbeitung
Nachteile
sehr langsam
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Verschmelzung von Listenoperationen
Effizienzsteigerung durch Verschmelzen von Listenoperationen
benötigt Optimiererregeln
map g xs) = map (f.g) xs
Beispiel: map f (map
erspart Listen als Zwischenergebnisse
bekannte Systeme
foldr
foldr/build
unfoldr
foldl
foldl/unfoldr
stream-fusion, ähnlich zu unfoldr
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Verschmelzung von Listenoperationen: Probleme
Optimierer wendet Regeln nicht immer an
Optimierer wendet Regeln nicht immer wie beabsichtigt an
Konflikte mit INLINE und SPECIALISE
Probleme mit Optimierer sehr schwer zu untersuchen
manches lässt sich nicht in Regeln schreiben
Beispiel: Rückkopplung
selbst eine einzige Liste kostet zu viel Zeit
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
StorableVector
Liste von Blöcken mit Rohdaten
Vorteile
sehr schnell
Gabelungen mit Pufferung
Nachteile
Rückkopplung mit Verzögerung abhängig von Blockgröße
nur Haskell-Datentypen mit maschinennaher Darstellung
Storable-Klasse
zip
zip, Alternativen:
behalte alle Blockgrenzen: zu viele kleine Blöcke
behalte nicht alle Blockgrenzen: zu viele Abhängigkeiten
Verschmelzung von Operationen
entweder inkorrekt oder ineffizient
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Verschmelzung Listen mit StorableVector
storablevector-streamfusion
Optimierungen werden nicht zuverlässig angewendet
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Listengenerator
Wenn man Funktion hat, braucht man keine Daten
data Generator a =
forall s . Generator ( StateT s Maybe a ) s
Generator ist Liste ohne Speicher“
”
benötigt nur INLINE statt RULES
etwas zuverlässiger
alle Haskell-Datentypen
enthält auch Überraschungen
keine Gabelungen
keine Rückkoppelungen
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Listengenerator vs. Listen
Listengenerator und Listen sind gleichmächtig
lis tFromGenerat or :: Generator a -> [ a ]
lis tFromGenerat or ( Generator f s ) =
unfoldr ( runStateT f ) s
List .unfoldr
gen eratorFromLi st :: [ a ] -> Generator a
gen eratorFromLi st =
Cons ( StateT (\ s ->
case s of
[]
-> Nothing
a : as -> Just (a , as )))
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Generatoren und Gabelungen
oscillator
envelope
exponential
oscillator
stereo
envelope
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Generatoren und Gabelungen
let env = exponential
in zipWith stereo
( envelope env osciLeft )
( envelope env osciRight )
Problem
exponential wird zweimal berechnet
Grund: env bezeichnet nicht Daten der Hüllkurve,
sondern erzeugende Funktion
Beobachtung
jeder Abtastwert von exponential wird sofort konsumiert
Zwischenspeicherung von env unnötig
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Kausale Prozesse
Problem: Gabelung auf Ebene eines Abtastwertes
Lösung: kausaler Prozess
data Causal a b = forall s .
Causal ( a -> StateT s Maybe b ) s
Ausgabewert hängt nur
von aktuellem und früheren Eingabewerten ab
Arrow statt Funktion
Arbeit mit Arrow-Kombinatoren ( pointfree style“)
”
Spezielle Arrow-Notation (in GHC oder mit Präprozessor)
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Kausale Prozesse
oscillator
:: Generator a
exponential
:: Generator a
envelope
:: Causal (a , a ) a
zipWith stereo :: Causal (a , a ) ( Stereo a )
apply :: Causal a b ->
Generator a -> Generator b
apply
(( applyFirst envelope oscillator0 &&&
applyFirst envelope oscillator1 )
>>>
zipWith stereo )
exponential
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Maximale Effizienz mit LLVM
Low-Level Virtual Machine
Compiler-Backend
portabler Assembler
Unterstützung Vektoreinheiten von CPU
Haskell-Schnittstelle llvm
Adaption von
Generator
kausaler Prozess
Kombinatoren bauen LLVM-Code zusammen
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Maximale Effizienz mit LLVM
Genaue Steuerung von INLINE
Genaue Angabe des Übersetzungszeitpunktes
Übersetzung zur Laufzeit
Benutzung in GHCi
über StorableVector Austausch mit Haskell-Code
neues Problem
Code für Instrument einmal erzeugen
Parameter (Tonhöhe, Länge) später übergeben
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Fazit
Probleme
Listen sind immer noch am schönsten,
aber am wenigsten effizient
Optimierung essentiell, aber unzuverlässig
Speicherlecks wegen Bedarfsauswertung
Arrows sind nötig, aber irgendwie auch hässlich
Benötigt:
Möglichkeit des Eingriffs,
um Speicherleck zu verhindern
Deklarativität wird aufgegeben,
Modularität muss erhalten bleiben
Haskell musiziert
Signalverarbeitung
Effizienz: Datenstrukturen
Was nun?
Nach so vielen Abstrichen:
Was ist eigentlich noch der Vorteil von Haskell
gegenüber einer imperativen Sprache?
Haskell musiziert
Musik
1 Übersicht
2 Signalverarbeitung
3 Musik
4 Abschluss
Haskell musiziert
Musik
Echtzeit
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Musik
Echtzeit
Echtzeitverarbeitung
Midimory
Memory mit Tönen
Haskell musiziert
Musik
Echtzeit
Echtzeitverarbeitung
MIDI via ALSA
Schema:
Klaviatur → Stromeditor → Synthesizer → Lautsprecher
MIDI-Stromeditor reactive-balsa
empfängt MIDI-Nachrichten
sendet veränderte MIDI-Nachrichten
erzeugt neue MIDI-Nachrichten nach eigenem Takt
Haskell musiziert
Musik
Echtzeit
Anwendungen
setze parallel gedrückte Tasten in serielles Muster um
wandele Instrumentwechsel-Befehle um
wechsle Instrument nach jeder Note: Tomatensalat“
”
Klaviatur aufteilen
Linkshänderklavier
Tasten auf Regler abbilden
Intervall-Gehörschule
Haskell musiziert
Musik
Echtzeit
Funktionale reaktive Programmierung
FRP: functional reactive programming“
”
Unterscheidung zwischen Ereignis und Zustand
Ereignisse: Taste gedrückt oder losgelassen, Regler bewegt
Zustand: Menge gedrückter Tasten, Reglerstand
weitere Anwendungen: GUI, Robotik, Animation
reactive-banana:
funktionaler Stil (nicht Arrows)
Monad: Erzeugung neuer Ereignisse
Haskell musiziert
Musik
Echtzeit
Echtzeitverarbeitung mit Listen (alt)
type EventList a = [( RelativeTime , a )]
type Process a b =
EventList a -> EventList b
einfaches Entfernen und Hinzufügen von Ereignissen
Berechnen von RelativeTime heißt
Warten bis Zeit verstrichen
Echo-Events
Unlösbar: Aufteilen und später Zusammenführen des Stromes
Paket: streamed
Haskell musiziert
Musik
Echtzeit
Echtzeitverarbeitung mit Prozessen (alt)
data Process a b = forall s c . Process
( StateArrow s
Either c a ) (b , EventList c ))
(Either
(s , EventList c )
Zustand von Typ s
Taktereignis von Typ c
Eingabe: Entweder Takt oder externes Ereignis
Ausgabe: verarbeitetes Ereignis und neue Taktereignisse
beginne mit Startzustand und -taktereignissen
Haskell musiziert
Musik
Echtzeit
Echtzeitverarbeitung mit Prozessen (alt)
Kombinatoren ähnlich zu Arrow
map :: -- Arrow . arr
( a -> b ) -> Process a b
compose :: -- Category ..
Process b c -> Process a b ->
Process a c
guide ::
( a -> Bool ) -> Process a b ->
Process a b -> Process a b
Arrow.first nicht möglich
Haskell musiziert
Musik
Komposition
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Musik
Komposition
Haskore
Paul Hudak: The Haskell School of Expression.
”
Learning Functional Programming Through Multimedia“
Algebra der Musik
sequentielle (+:+) und parallele (=:=) Komposition
Rechengesetze
(a +:+ b) +:+ c = a +:+ (b +:+ c)
(a =:= b) =:= c = a =:= (b =:= c)
a =:= b = b =:= a
..
.
Fortschritt gegenüber SoundTracker&Co.:
Formulierung von Ideen, weniger Kopieren von Abschnitten
Haskell erlaubt gleichzeitig
Musikarrangement und Signalerzeugung
Haskell musiziert
Musik
Komposition
Begleithilfen
regelmäßige aber nicht-periodische Muster:
Quersummen der natürlichen Zahlen modulo 4 im 4er-System
Gitarrenakkorde
Haskell musiziert
Musik
Komposition
Wiedergabemöglichkeiten
Haskell-Synthesizer
Unter Wasser: Bandpass auf Sägezahn
Häcksler: FM-Synthese
Schwanensee: Bandpass spielt Melodie auf Akkordbegleitung
MIDI-Dateien: ChildSong
CSound: Alle Vögel sind schon da
SuperCollider
Glissando
Chill out
Notenblatt (noch zu erledigen)
Haskell musiziert
Musik
Komposition
Haskore: Aufbau
Melody (ohne Instrumente)
Music (mit Instrumenten)
Player: Interpretation
Performance
Back-End: MIDI, CSound, SuperCollider . . .
Haskell musiziert
Musik
Komposition
Haskore: Music-Typ
data Music instr =
Note Pitch Dur instr
| Rest Dur
| Serial [ Music instr ]
| Parallel [ Music instr ]
| Tempo Rational ( Music instr )
| Transpose Int ( Music instr )
| Player Name ( Music instr )
| Phrase PhraseAttribute ( Music instr )
Haskell musiziert
Musik
Komposition
Wunschliste
mehr Interaktivität in Editor oder Entwicklungsumgebung
Klangausgabe bei Tastendruck im Editor
Noteneingabe in Editor über MIDI/ALSA
Hervorhebung aktuell gespielter Note bei Wiedergabe
Haskell musiziert
Musik
Live-Sequencer
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Musik
Live-Sequencer
Interaktiver Haskell-Sequenzer
Änderungen am laufenden Musikstück
gemeinsame Komposition über Netzwerk
Demonstration Arbeitsweise Interpreter
stark vereinfachtes Haskell, untypisiert, kein Sharing“
”
benötigt externe Klangerzeuger
Haskell musiziert
Abschluss
1 Übersicht
2 Signalverarbeitung
3 Musik
4 Abschluss
Haskell musiziert
Abschluss
Bezugsquellen
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Abschluss
Bezugsquellen
Assampler
Amiga-Assampler
Präsenz: http://www.assampler.de/
Saugen: http://aminet.net/search?query=assampler
Amiga-Emulator:
Linux: http://www.rcdrummond.net/uae/
Windows: http://www.winuae.net/
Haskell musiziert
Abschluss
Bezugsquellen
Haskore
Internetpräsenz von Paul Hudak für Original-Haskore:
http://www.haskell.org/haskore/
Auf Haskore basierende Projekte:
http://www.haskell.org/haskellwiki/Haskore
Grundlegend überarbeitetes Paket:
http://code.haskell.org/haskore/revised/
haskore: MIDI-Dateien, CSound
haskore-supercollider: SuperCollider
haskore-synthesizer: Verbindung mit synthesizer
Weiterentwicklung von Paul Liu Euterpea
Haskell musiziert
Abschluss
Bezugsquellen
Klangsynthese
synthesizer-core, synthesizer-dimensional
synthesizer-alsa, synthesizer-midi,
synthesizer-llvm
unterstützt sox für Klangwiedergabe
und Konvertierung in übliche Audioformate
Für Demonstrationen:
http://code.haskell.org/~thielema/dafx/
Haskell musiziert
Abschluss
Bezugsquellen
SuperCollider
SuperCollider: Echtzeit-Synthesizer von James McCartney
http://www.audiosynth.com/
Ansteuerung mit Haskell
Open Sound Control: hosc
SuperCollider: hsc3
opensoundcontrol-ht, supercollider-ht
Haskell musiziert
Abschluss
Bezugsquellen
SuperCollider-Beispiele
osc-Dateien enthalten Kommandos für SuperCollider
Audiodaten berechnen:
$ scsynth -D 0 -o 2 -N song.osc _ song.aiff 44100 AIFF int16
$ bunzip2 --stdout song.osc.bz2 | \
scsynth -D 0 -o 2 -N _ _ song.aiff 44100 AIFF int16
Haskell musiziert
Abschluss
Bezugsquellen
CSound
Sound-Compiler“ von Barry Vercoe
”
http://www.csounds.com/
Sprache für Beschreibung von Klängen (Orchestra)
Liste von Klangereignissen (Score)
Haskore erzeugt beide Dateiarten
Weitere Schnittstellen: csound-expression, hCsound
Haskell musiziert
Abschluss
Bezugsquellen
Live-Sequencer
live-sequencer
http://www.haskell.org/haskellwiki/Live-Sequencer
etliche Videos auf DuRöhre
Haskell musiziert
Abschluss
Weitere Informationen
1 Übersicht
2 Signalverarbeitung
Grundlagen
Signalalgorithmen
Sicherheit: Physikalische Einheiten
Effizienz: Datenstrukturen
3 Musik
Echtzeit
Komposition
Live-Sequencer
4 Abschluss
Bezugsquellen
Weitere Informationen
Haskell musiziert
Abschluss
Weitere Informationen
Nicht zu vergessen . . .
Diskussionen über Haskell und Kunst:
http://lists.lurk.org/mailman/listinfo/haskell-art
Digitale Signalverarbeitung mit Haskell
von Matthew Donadio:
http://haskelldsp.sourceforge.net/, dsp
Physikalische Klangmodellierung mit Clean
von Jerzy Karczmarczuk:
“Functional Framework for Sound Generation”
http://users.info.unicaen.fr/~karczma/arpap/cleasyn.pdf
Haskell musiziert
Abschluss
Weitere Informationen
Weitere Projekte
Daniel van den Eijkel: hommage
Rohan Drape: hmt, hdf
George Giorgidze: YampaSynth
Samuel Silva: hamusic (MusicXML)
...