Autor-Archiv Marlon Schumacher

  • Home   /  
  • Beiträge von Marlon Schumacher

Smart Speaker Evaluation

Fragestellung

Im Rahmen des Designs eines Distributed Smart Speaker Arrays*, ob AoIP (Audio over IP) Lautsprecher der Firma Genelec hierfür geeignet sind und voraussetzende Kriterien erfüllen.

Kriterien zur Examinierung der Lautsprechermodelle 4420A und 4430A.

Die Genelec AoIP Lautsprecher bieten folgende Vorteile:

  • Übertragung von Strom,  Audio und Konfigurationsdaten mit nur einem Kabel.
  • Der Interne DSP der Lautsprecher kann via Netzwerk konfiguriert werden, und bietet 20 Filter an, zudem delay und Gesamtlautstärke
  • Es können sowohl Digital (RJ45 AES67) als auch Analog (Euroblock) Eingänge gleichzeitig mit interner Mischung verwendet werden
  • Es besteht eine offizielle public API.
  • Dimensionen sind klein genug (ca 15cm Breite, s. Spatial Aliasing), um kontinuierliche Arrays zur Holophonie (Wellenfeldsynthese, kompakte Arrays, ein/auslaufende Schallfelder, etc.) einzusetzen

Testziele:

  • DSP Parameter setzen (über API, ohne Herstellereigene Software)
  • Relative Latenz mehrer Lautsprecher (selber Stream)
  • Lautstärke/Schalldruck (aufgrund der kleinen Dimensionen)
  • Verhalten bei hohen Pegeln (Klirrfaktor, etc.)
  • Steuerprotokoll-Dokumentation der internen API
  • Latenz bei Steuerung der internen DSP Einstellungen über API

 

Vorläufige Evaluation

Steuerung

Die Lautsprecher werden per REST-Schnittstelle gesteuert. Der Hersteller bietet eine öffentliche API, die einige Einstellungen erlaubt. Die Software zur Konfiguration nutzt ebenfalls diese REST-API, jedoch mit mehr Endpunkten. Mit Hilfe von Wireshark konnte die Kommunikation direkt mitgelesen werden. Es findet keinerlei Verschlüsselung statt. 

 

Dank an Stephan Westfal für Durchführung der Tests.

 

Zylia 6DOF navigable audio

Zylia’s ZM-1 microphone is designed for three-dimensional recording. It allows the user to record sound scenes and separate single sound sources though a combination of microphone array technology and digital signal processing algorithms.

The spherical microphone has 19 capsules that each have an omni-directional polar pattern and that use Micro-Electro-Mechanical Systems (MEMS) technology. The durable casing features an LED ring status indicator. It is capable of recording at sample rates of 44.1 and 48 kHz and 24- bit sample depth. Gain adjustment controls in steps of 0.5 dB from −12 dB to +32 dB are provided. The microphone is 6.1 in high and 4 in in diameter. It weighs 15.5 oz. The ZM-1 has an integrated desktop stand and it can be mounted on microphone stands that use 1⁄4-in and 5⁄8- inthreads. It connects to computers using a micro-USB port in the base.

Zylia Studio is a software application for recording and processing from the Zylia microphone. It can be used to balance and pan the multichannel recording and to separate it into individual audio tracks for use in a digital audio workstation (DAW), if required. Two separation modes are available, a virtual microphone mode and a high separation mode. The first of these mimics a directional microphone and allows any part to be isolated from the three-dimensional space. The high separation mode uses an additional process to mimic the behavior of a close microphone, reducing ambient sounds and background noise and giving even better sound source separation. The audio can be stored as PCM WAV files or using a lossless compression that reduces the size by half. The software is compatible with Macintosh, Windows, and Linux operating systems.

A PRO version of the software is available as a VST/AU plug-in. This provides spatial filtering and signal separation tools within a DAW and gives the user access to virtual microphones with different polar patterns and characteristics in post-production. A number of different group and surround sound presets are provided.

An Ambisonics converter can process convert multi-channel audio into b-format higher-order Ambisonics. It also supports FuMA or ACN channel ordering and SN3D or N3D normalization. It is also compatible with YouTube’s ambiX and Facebook’s TBE formats. The converter is available as a standalone application or as a VST plug-in.

SPCL – 2a) Variablen, Scoping

In dieser Einheit haben wir uns mit Variablen und Scoping (Gültigkeitsbereichen) beschäftigt. Insbesondere haben wir Konzepte zu lexicalische vs dynamische, sowie lokale vs. globale Gültigkeitsbereiche studiert. Hier finden Sie eine kurze Zusammenfassung. Im Zshg. mit diesem Thema findet sich am Ende des Beitrags noch ein interessantes Video zum Lambda Calculus, bzw. dem Unterschied zwischen zustands-basierten (state-based) und funktionalen (functional) Sprachen.

Variablen

Lokale Variablen

  • let => erzeugt lokale, lexikalische  Variablen. Beispiel:

(let ((x 5) (y 10))
(+ x y)
)

=> 15 ;  x und y können innerhalb des let-statements benutzt werden

Globale Variablen:

  • defvar => erzeugt Variable und weist einen Wert zu, allerdings nur wenn die Variable noch nicht definiert wurde. Beispiel:

(defvar *mydefvar* 'something)

  • defparameter => erzeugt Variable und weist ihr einen Wert zu. Beispiel:

(defparameter *mydefparameter* 'anotherthing)

  • defconstant => erzeugt eine Konstante. Beispiel:

(defconstant +pi+ 3.14)

; => globale Variablen sind (wie der Name schon sagt) global existent und überall benutzbar. PS Bitte beachten Sie die “earmuffs” Notation für globale *Variable*, bzw. +Konstanten+.

(* +pi+ 2)

=> 6.28

Setz-Operatoren

Die Werte von existenten lexikalischen und dynamischen Variablen lassen sich mit Setz-Operatoren (set, setq, setf) setzen*.

(let ((something 2.3))
(setq something 1)
(print  something)
)

; => “1”

(setq *mydefparameter* 5.0)
(print *mydefparameter*)

; => “5”

*Konstanten können nicht mit Setz-Operatoren verändert oder mit neuen Werten gebunden werden. Beispiel:

(setf  +pi+ 1.0) ; => ERROR

Lexikalisch (statisch)  vs  Dynamisch (special) 

  • Lexikalisch: Der Wert der Variablen wird durch den umgebenden Text (also “räumlich”) der Funktionsdefinition bestimmt. Beispiel:

(let ((x 5))
          (defun return-x () x)
)

(let ((x 10))
         (return-x)
)

=> 5 ;   der Wert von x aus der Umgebung der Funktionsdefinition

  • Dynamisch: Der Wert der Variablen wird zur Funktionslaufzeit (also zeitlich) bestimmt. Beispiel:

(defparameter *x* 5)

(defun return-x () *x*)

(setf *x* 10)

(return-x)

=> 10 ; der Wert von *x* zur Laufzeit der Funktion

Closures

Als Closure wird ein Konstrukt (Umgebung und Funktionsdefinition) bezeichnet, welches Funktionen Zugriff auf (lexikalische) Variablen erlaubt, die ausserhalb der Funktionsdefinition selbst, jedoch innerhalb des lexikalischen Scopes in der die Funktionen definiert wurden, gebunden sind. Beispiel:

(let ((number 10))
           (defun add1 () (incf number))
(defun sub1 () (decf number))
)

(add1) , => 11, 12, 13, ...

(sub1), => 9, 8, 7, ...

; Obwohl die Variable ‘number’ nicht innerhalb der Funktionen add1 und sub1 definiert wurde, kann Sie dennoch verwendet (und verändert) werden.

Für mehr Lektüre zu Variablen und Scoping empfehle ich Ihnen dringend diesen sehr guten Text:

http://www.gigamonkeys.com/book/variables.html

Hier eine Beschreibung aus Wikipedia:

Lexical scope vs. dynamic scope

A fundamental distinction in scoping is what “part of a program” means. In languages with lexical scope (also called static scope), name resolution depends on the location in the source code and the lexical context, which is defined by where the named variable or function is defined. In contrast, in languages with dynamic scope the name resolution depends upon the program state when the name is encountered which is determined by the execution context or calling context. In practice, with lexical scope a variable’s definition is resolved by searching its containing block or function, then if that fails searching the outer containing block, and so on, whereas with dynamic scope the calling function is searched, then the function which called that calling function, and so on, progressing up the call stack.[4] Of course, in both rules, we first look for a local definition of a variable.

Most modern languages use lexical scoping for variables and functions, though dynamic scoping is used in some languages, notably some dialects of Lisp, some “scripting” languages like Perl, and some template languages.[c] Even in lexically scoped languages, scope for closures can be confusing to the uninitiated, as these depend on the lexical context where the closure is defined, not where it is called.

Lexical resolution can be determined at compile time, and is also known as early binding, while dynamic resolution can in general only be determined at run time, and thus is known as late binding.

Spat Convert

SpatDIF DAW Plugin ITM

Supercollider Renderer

Spat-based Renderer

Spat Visualizer

SPCL – 1) Formen, S-Expressions, Funktionen

Einführung in die Sprache Common LISP

In dieser Unterrichtseinheit wird die Sprache Common LISP eingeführt. Hierzu betrachten wir Besonderheiten dieser Sprache, insbesondere die Syntax: sog. „S-Expressions“ (symbolic expressions) und Prefix (oder „Polish“) Notation. Des Weiteren befassen wir uns mit dem Konzept der  Evaluierung von Formen unter Berücksichtigung der Äquivalenz von Daten und Funktionen: „A lisp form is a lisp datum that is also a program, that is, it can be evaluated without an error.„

Wir haben uns mit der Evaluierungsreihenfolge studiert. Lisp evaluiert Formen rekursiv. Hierzu ein kleines Beispiel aus diesem online LISP Tutorial. Folgende form soll evaluiert werden:

(+ 33 (* 2.3 4)) 9)

  1. The + function is looked up.
  2. 33 is evaluated (its value is 33).
  3. (* 2.3 4) is evaluated:
    1. The * function is looked up.
    2. 2.3 is evaluated (its value is 2.3)
    3. 4 is evaluated (its value is 4)
    4. 2.3 and 4 are passed to the * function.
    5. The * function returns 9.2. This is the value of (* 2.3 4).
  4. 9 is evaluated (its value is 9).
  5. 33, 9.2, and 9 are passed to the + function.
  6. The + function returns 51.2. This is the value of (+ 33 (* 2.3 4) 9).
  7. The Lisp system returns 51.2.

Wir haben sodann verschiedene Datentypen kennengelernt: symbols, floats, integers und ratios.

Wir haben unsere ersten Programmierversuche gestartet und unsere ersten kleinen LISP forms geschrieben. Dabei haben wir sog. „primitive functions“ (Funktionen, die bereits in der Sprache implementiert sind) verwendet, um Operationen mit Daten auszuführen. Diese waren: (*für die u.s. Tabellen nehmen wir an, die  Variable A hätte den Wert 10 und Variable B den Wert 20) :

Arithmetische Operatoren

+, -, *, /, mod, rem, incf, decf

Operator Description Example
+ Adds two operands (+AB) will give 30
– Subtracts second operand from the first (- A B) will give -10
* Multiplies both operands (* A B) will give 200
/ Divides numerator by de-numerator (/ B A) will give 2
mod, rem Modulus Operator and remainder of after an integer division (mod B A) will give 0
incf Increments operator increases integer value by the second argument specified (incf A 3) will give 13
decf Decrements operator decreases integer value by the second argument specified (decf A 4) will

Prädikatsfunktionen

equalp, symbolp, numberp, oddp, evenp

Operator Description Example
equalp Checks if the values of the two arguments are equal (= A B) is not true.
symbolp Checks if the value of the argument is a symbol (symbolp A) is not true
numberp Checks if the value of the argument is a number (numberp A) is true.
oddp Checks if the value of the argument (integer) is odd (oddp A) is not true
evenp Checks if the value of the argument (integer) is even (evenp A) is true

Vergleichsoperatoren

=, /=, >, <, >=, <=, max, min

Operator Description Example
= Checks if the values of the operands are all equal or not, if yes then condition becomes true. (= A B) is not true.
/= Checks if the values of the operands are all different or not, if values are not equal then condition becomes true. (/= A B) is true.
> Checks if the values of the operands are monotonically decreasing. (> A B) is not true.
< Checks if the values of the operands are monotonically increasing. (< A B) is true.
>= Checks if the value of any left operand is greater than or equal to the value of next right operand, if yes then condition becomes true. (>= A B) is not true.
<= Checks if the value of any left operand is less than or equal to the value of its right operand, if yes then condition becomes true. (<= A B) is true.
max It compares two or more arguments and returns the maximum value. (max A B) returns 20
min It compares two or more arguments and returns the minimum value. (min A B) returns 20

 

Logische Operatoren

Hierfür nehmen wir an, A hat den Wert NIL (false) und B hat den Wert 5 (true).

Operator Description Example
and It takes any number of arguments. The arguments are evaluated left to right. If all arguments evaluate to non-nil, then the value of the last argument is returned. Otherwise nil is returned. (and A B) will return NIL.
or It takes any number of arguments. The arguments are evaluated left to right until one evaluates to non-nil, in such case the argument value is returned, otherwise it returns nil. (or A B) will return 5.
not It takes one argument and returns t if the argument evaluates to nil. (not A) will return T.

Danach haben wir die Macro Funktion „defun“ kennen gelernt, um unsere eigenen Funktionen zu definieren. Dies haben wir dann mit der Programmierung eines kleinen Würfelspiels zur Anwendung gebracht.

Seiten: 1 2

SPCL – Rekursion

Tafelaufschrieb zu Rekursion (vgl. LISP code auf Ilias):

; Beispiel mit cond

(defun myfun ()
    (cond ([termination-condition] [termination-action])
          ([recursion-condition] (myfun ()))
     )
)

; Beispiel mit if

(defun myfun ()
 (if  [termination-condition] 
    [termination-action]
  (myfun ())
  )
 )

IMG_5400

Hier eine Visualisierung der Rekursiven Funktion zur Generierung von Fibonacci Zahlen. Code-Beispiel:

(defun fib1 (n)
 (if  (or (= n 1) (= n 0)) 
    1
  (+ (fib1 (- n 1)) (fib1 (- n 2)))
  )
 )
IMG_5402

Your browser doesn't support the HTML5 CANVAS tag.

Impressum | Datenschutzerklärung