AudioKit est un framework audio développé par des ingénieurs du son, des programmeurs et des musiciens spécialement pour iOS et OSX. Il fournit des outils pour le
traitement et la
synthèse du son. Sous le capot se trouve un mélange de Swift, Objective-C, C ++ et C et l'API Audio Unit d'Apple. Des technologies impressionnantes (et plutôt sophistiquées) sont enveloppées dans une API Swift très conviviale, accessible directement depuis Xcode Playgrounds!
Dans ce tutoriel, nous allons faire un voyage à travers AudioKit, ainsi que l'
histoire de la synthèse sonore. Vous apprendrez les bases de la physique du son et le fonctionnement des premiers synthétiseurs comme l'orgue Hammond. De plus, les techniques modernes, par exemple l'échantillonnage, seront envisagées.
Faites votre boisson préférée, asseyez-vous et c'est parti!
Première étape
Depuis AudioKit 3.6, la configuration des aires de jeux pour fonctionner avec le framework est devenue assez simple. Téléchargez et décompressez la playlist de démarrage
ici .
Le voyage commence par quelques étapes pour configurer les aires de jeux pour travailler avec AudioKit.
Ouvrez le fichier
AudioKitPlaygrounds.xcodeproj dans Xcode. Cliquez sur le bouton
+ dans le coin inférieur gauche de l'écran, sélectionnez
Fichier ... puis
Vide dans la section
Playground , enregistrez le nouveau fichier dans le dossier Playgrounds avec les aires de jeux de démonstration.
Le terrain de jeu nouvellement ajouté commencera et ressemblera à ceci:
Remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit let oscillator = AKOscillator() AudioKit.output = oscillator try AudioKit.start() oscillator.start() sleep(10)
Le terrain de jeu ne démarrera que lorsque vous aurez assemblé le projet au moins une fois. Pour cela, vous pouvez utiliser l'élément de menu
Produit / Construire ou la combinaison de touches
⌘-B . Après cela, exécutez à nouveau le terrain de jeu et entendez un bourdonnement pendant 10 secondes. (Note du traducteur: parfois l'erreur ne disparaît pas, et vous devez basculer sur un autre terrain de jeu et revenir pour le faire fonctionner). Vous pouvez utiliser le bouton Play / Stop en bas à gauche de la fenêtre de lecture pour arrêter la lecture ou la redémarrer.
Remarque: Si vous voyez toujours des erreurs, essayez de redémarrer Xcode. Malheureusement, les cadres et les terrains de jeux ne sont pas très bons amis et peuvent se comporter de façon imprévisible.
Oscillateurs et physique du son
L'humanité joue de la musique à travers divers objets physiques depuis des milliers d'années. Beaucoup de nos instruments habituels, comme les guitares ou les tambours, ont des centaines d'années. La première expérience enregistrée d'utilisation de circuits électroniques pour générer du son a été réalisée en 1874 par Elias Gray. Elisha a travaillé dans le domaine des télécommunications, et il a inventé l'oscillateur - le plus simple des synthétiseurs musicaux. Avec lui, nous commencerons notre plongée.
Cliquez avec le bouton droit sur votre terrain de jeu, sélectionnez
Nouvelle page de terrain de jeu et remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit import PlaygroundSupport
Le terrain de jeu commencera à générer un buzz continu - comme prévu. Vous pouvez cliquer sur stop pour l'arrêter.
C'est presque la même chose que ce que nous avons fait dans le terrain de jeu précédent, mais cette fois, nous allons plonger dans les détails.
Considérez toutes les étapes dans l'ordre:
- Ici, nous créons un oscillateur. L'oscillateur est le successeur d'
AKNode . Les nœuds sont les éléments qui composent une chaîne audio qui génère et modifie le son.
- Ici, nous connectons la sortie de notre dernier nœud avec le moteur AudioKit. Dans notre cas, un seul nœud. En outre, le cadre dirigera la sortie du nœud vers le périphérique de lecture audio.
- Eh bien, nous démarrons l'oscillateur, sur la sortie il commence à envoyer une onde sonore.
L'oscillateur génère un signal répétitif qui ne s'arrête pas. Dans ce manuel,
AKOscillator génère une onde sinusoïdale. À l'aide de l'AudioKit, un signal sinusoïdal numérique est envoyé aux haut-parleurs ou au casque. En conséquence, nous entendons un son qui oscille à la même fréquence que l'onde sinusoïdale que nous avons générée. Cette onde sinusoïdale ne semble pas très musicale.
Deux paramètres sont responsables du son de cet oscillateur: l'amplitude - la hauteur de l'onde sinusoïdale, détermine le volume et la fréquence du son - la hauteur du son en dépend.
Dans la cour de récréation, ajoutez les lignes de code suivantes juste après avoir créé l'oscillateur:
oscillator.frequency = 300 oscillator.amplitude = 0.5
Le son a changé, il sonne maintenant deux fois plus silencieux et beaucoup plus bas. La fréquence du signal est mesurée en hertz (nombre de répétitions par seconde) et détermine la hauteur de la note. L'amplitude (amplitude) est réglée de 0 à 1 et est responsable du volume.
L’invention d’Elijah Gray a été enregistrée dans le tout premier brevet pour un instrument de musique électronique.
Plusieurs années plus tard, Leo Theremin a inventé un instrument de musique légèrement étrange utilisé à ce jour - le theremin. Dans le theremin, vous pouvez changer la fréquence du son avec des mouvements de la main au-dessus de l'instrument. Pour comprendre comment le theremin sonne, vous pouvez écouter les vibrations des Beach Boys, et il n'y a rien à confondre avec le theremin.
Vous pouvez simuler le son de thereminvox, pour cela, ajoutez le code suivant aux paramètres de l'oscillateur:
oscillator.rampDuration = 0.2
Et remplacez la ligne commençant AudioKit (
try AudioKit.start() ) par ce qui suit:
let performance = AKPeriodicFunction(every: 0.5) { oscillator.frequency = oscillator.frequency == 500 ? 100 : 500 } try AudioKit.start(withPeriodicFunctions: performance) performance.start()
La propriété
rampDuration permet à l'oscillateur de modifier en douceur les valeurs de ses paramètres (par exemple, la fréquence ou l'amplitude).
AKPeriodicFunction est un utilitaire utile d'AudioKit pour l'exécution périodique de code. Dans notre exemple, il change la fréquence de l'onde sinusoïdale de 500 Hz à 100 Hz toutes les 0,5 secondes.
Félicitations! Vous venez de faire votre premier theremin. Un simple oscillateur peut générer des notes de musique, mais il ne sonne pas très bien. De nombreux facteurs affectent le son des instruments physiques, comme le piano par exemple. Et plus loin, nous examinerons certains d'entre eux.
Enveloppes sonores
Lorsqu'un instrument de musique joue une note, le volume de son son change avec le temps et la nature des changements diffère d'un instrument à l'autre. Un modèle qui peut simuler cet effet s'appelle l'enveloppe Attack-Decay-Sustain-Release (ADSR) (Remarque: les synthétiseurs disponibles à l'achat ne sont jamais localisés, donc le nom de la courbe est le même que celui visible sur le panneau de ce synthétiseur).
L'enveloppe ADSR comprend:
- Attack : attaque ou temps dans lequel le son atteint son volume maximum.
- Décomposition : sauvage ou temps pour lequel le volume passe du maximum au principal
- Sustain : le volume principal, contrairement aux deux paramètres précédents, n'est pas le temps, après le passage de l'attaque et des sauvages et avant de relâcher la touche synthétiseur, le son sera généré avec ce volume
- Release : release ou temps dans lequel le volume devient nul
Au piano, le son est extrait par des coups de marteau sur les cordes, et donc en lui sont rapides ou, disent-ils aussi, de courtes attaques et des wilds. Le violon peut avoir une longue attaque, sauvage et sustain, le musicien peut influencer ces paramètres par la façon dont il utilise l'archet.
Hammond Novachord est l'un des premiers instruments de musique électroniques. Cet instrument a été fabriqué en 1939, se composait de 163 tubes à vide et de plus de 1000 condensateurs, et il pesait 230 kilogrammes. Malheureusement, seulement quelques centaines d'exemplaires ont été réalisés et il n'a jamais obtenu de succès commercial.
Faites un clic droit sur
Journey Playground , sélectionnez
New Playground Page et créez une nouvelle page appelée
ADSR . Remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit import PlaygroundSupport let oscillator = AKOscillator()
Il crée simplement un oscillateur que nous connaissons déjà. Ensuite, ajoutez le code suivant à la fin de la cour de récréation:
let envelope = AKAmplitudeEnvelope(oscillator) envelope.attackDuration = 0.01 envelope.decayDuration = 0.1 envelope.sustainLevel = 0.1 envelope.releaseDuration = 0.3
Cela crée une
AKAmplitudeEnvelope qui définit l'enveloppe ADSR. Les paramètres de durée (attackDuration, decayDuration, releaseDuration) sont spécifiés en secondes et le volume (sustainLevel) est réglé dans une plage de 0 à 1.
AKAmplitudeEnvelope est le successeur de
AKNode de la même manière que
AKOscillator . Dans le code ci-dessus, nous passons les nœuds d'enveloppe de l'oscillateur à l'initialiseur, connectant ainsi les nœuds.
Ensuite, ajoutez le code suivant:
AudioKit.output = envelope let performance = AKPeriodicFunction(every: 0.5) { if (envelope.isStarted) { envelope.stop() } else { envelope.start() } } try AudioKit.start(withPeriodicFunctions: performance) performance.start() oscillator.start() PlaygroundPage.current.needsIndefiniteExecution = true
Il lancera AudioKit, mais cette fois, nous alimentons la sortie du nœud ADSR à son entrée. Afin d'entendre l'effet ADSR, nous
AKPeriodicFunction et désactivons constamment le nœud à l'aide de la fonction
AKPeriodicFunction .
Vous pouvez maintenant entendre comment la note est jouée en cycles, mais cette fois, elle ressemble un peu plus à un piano.
La boucle s'exécute deux fois par seconde à chaque itération, démarrant ou arrêtant l'ADSR. Lorsque l'ADSR commence par une attaque rapide, le volume atteint sa valeur maximale en 0,01 seconde, après quoi le volume diminue au niveau principal en 0,1 seconde et y reste pendant 0,5 seconde, et à la fin se désintègre en 0,3 seconde.
Vous pouvez jouer avec les paramètres vous-même et essayer de jouer, par exemple, le son d'un violon.
Les sons que nous avons rencontrés sont basés sur l'onde
AKOscillator générée par
AKOscillator . Bien que l'ASDR aide à atténuer les sons durs, vous ne pouvez toujours pas appeler ces sons musicaux.
De plus, nous verrons comment obtenir un son plus profond.
Synthèse additive
Chaque instrument de musique a son propre son ou timbre.
Un timbre est ce qui distingue les sons d'un piano des sons d'un violon, même s'ils peuvent jouer la même note. Un paramètre important du timbre est le spectre sonore. Le spectre sonore décrit la gamme de fréquences reproduites qui, additionnées, donnent une note. Notre terrain de jeu actuel utilise un oscillateur qui ne sonne qu'à une seule fréquence, et cela semble assez artificiel.
Vous pouvez obtenir un son plus vivant en utilisant un ensemble d'oscillateurs pour jouer une seule note. Cette approche est connue sous le nom de synthèse additive, et c'est le sujet de notre prochain terrain de jeu.
Cliquez avec le bouton droit sur le terrain de jeu, sélectionnez
Nouvelle page de terrain de jeu et créez une nouvelle page appelée
Synthèse additive . Remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit import AudioKitUI import PlaygroundSupport func createAndStartOscillator(frequency: Double) -> AKOscillator { let oscillator = AKOscillator() oscillator.frequency = frequency return oscillator }
Pour la synthèse additive, vous avez besoin de plusieurs oscillateurs, pour cela nous utiliserons.
createAndStartOscillatorEnsuite, ajoutez le code:
let frequencies = (1...5).map { $0 * 261.63 }
Ici, nous prenons un intervalle de nombres de 1 à 5 et multiplions chacun par 261,53, la fréquence de la note. Les fréquences multiples résultantes sont appelées harmoniques.
Ajoutez maintenant le code:
let oscillators = frequencies.map { createAndStartOscillator(frequency: $0) }
Ici, nous avons créé un oscillateur pour chacune des fréquences que nous utilisons.
Pour combiner des oscillateurs, ajoutez le code suivant:
let mixer = AKMixer() oscillators.forEach { $0.connect(to: mixer) }
AKMixer est un autre type de nœud AudioKit. Il reçoit les entrées d'un ou plusieurs nœuds et les combine en un seul.
Ajoutez le code suivant:
let envelope = AKAmplitudeEnvelope(mixer) envelope.attackDuration = 0.01 envelope.decayDuration = 0.1 envelope.sustainLevel = 0.1 envelope.releaseDuration = 0.3 AudioKit.output = envelope let performance = AKPeriodicFunction(every: 0.5) { if (envelope.isStarted) { envelope.stop() } else { envelope.start() } } try AudioKit.start(withPeriodicFunctions: performance) performance.start() oscillators.forEach { $0.start() }
Tout devrait être clair avec ce code: ajoutez l'ADSR à la sortie du mixeur, sortez via AudioKit et allumez / éteignez périodiquement.
Afin de bien gérer la synthèse additive, il sera utile de jouer avec différentes combinaisons de ces fréquences. Et en cela, l'opportunité de terrains de jeux comme Live View est idéale pour nous.
Pour ce faire, ajoutez le code:
class LiveView: AKLiveViewController { override func viewDidLoad() { addTitle("Harmonics") oscillators.forEach { oscillator in let harmonicSlider = AKSlider( property: "\(oscillator.frequency) Hz", value: oscillator.amplitude ) { amplitude in oscillator.amplitude = amplitude } addView(harmonicSlider) } } } PlaygroundPage.current.needsIndefiniteExecution = true PlaygroundPage.current.liveView = LiveView()
Dans AudioKit, il existe des classes spécialement conçues pour un travail pratique dans les aires de jeux. Dans notre exemple,
AKLiveViewController utilisons
AKLiveViewController , en l'utilisant nous
AKLiveViewController verticalement des éléments. Et aussi pour chaque oscillateur, nous créons un
AKSlider . Les curseurs sont initialisés par les valeurs de la fréquence et de l'amplitude des oscillateurs et provoquent un blocage lors de l'interaction avec eux. Dans le bloc de chaque curseur, nous modifions l'amplitude de l'oscillateur correspondant. Vous pouvez donc simplement ajouter de l'interactivité à vos aires de jeux.
Pour voir les résultats du terrain de jeu, vous devez avoir Live View affiché à l'écran. Pour ce faire, sélectionnez le bouton avec des cercles entrecroisés dans la partie supérieure droite de la fenêtre et assurez-vous que la liste de lecture correcte est sélectionnée pour Live View.
Afin de changer la tonalité de votre instrument, vous pouvez changer les valeurs de chaque curseur individuellement. Pour un son réaliste, je vous suggère d'essayer la configuration indiquée dans la capture d'écran ci-dessus.
Teleharmonium était l'un des premiers synthétiseurs à utiliser la synthèse additive et il pesait 200 tonnes! Son poids et sa taille incroyables sont probablement devenus la raison de son obscurité. L'orgue Hammond le plus performant utilisait des roues phoniques similaires, mais était beaucoup plus petit. Inventé en 1935, il est encore largement connu comme un instrument populaire à l'ère du rock progressif.
La roue phonique est un disque rotatif avec de petites cavités le long du bord et un capteur situé près du bord. L'orgue Hammond avait tout un ensemble de roues phoniques qui pouvaient tourner à différentes vitesses. Une façon plutôt inhabituelle de générer du son est plutôt électromécanique qu'électronique.
Afin de générer un spectre sonore plus réaliste, il existe plusieurs autres techniques: modulation de fréquence (modulation de fréquence ou FM) et modulation de largeur d'impulsion (modulation de largeur d'impulsion ou PWM), les deux techniques sont disponibles dans AudioKit dans les
AKPWMOscillator AKFMOscillator et
AKPWMOscillator respectivement. Je vous suggère d'essayer les deux, en les remplaçant au lieu de l'
AKOscillator , que nous avons utilisé plus tôt.
Polyphonie
Dans les années 1970, le mouvement est passé de synthétiseurs modulaires, constitués d'oscillateurs et de filtres à enveloppe séparée, à des microprocesseurs. Au lieu d'utiliser des circuits analogiques, le son a commencé à être généré au format numérique. Cela a rendu les synthétiseurs moins chers et plus compacts, et les synthétiseurs de marques comme Yamaha très populaires.
Tous nos terrains de jeux étaient limités à jouer une note à la fois. De nombreux instruments sont capables de jouer plus d'une note à la fois, ils sont appelés
polyphoniques . Les instruments qui ne peuvent jouer qu'une seule note sont appelés
monophoniques .
Afin d'obtenir un son polyphonique, vous pouvez créer plusieurs oscillateurs et les envoyer au mélangeur, mais dans AudioKit, il existe un moyen plus approprié pour cela.
Créez une nouvelle page dans la cour de récréation et nommez-la Polyphonie. Remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit import AudioKitUI import PlaygroundSupport let bank = AKOscillatorBank() AudioKit.output = bank try AudioKit.start()
Ici, nous avons créé la banque d'oscillateurs
AKOscillatorBank . Si vous allez à la déclaration de classe, vous pouvez constater que c'est l'héritier de
AKPolyphonicNode , qui, à son tour, est l'héritier de l'
AKNode déjà connu de nous, et met également en œuvre le protocole
AKPolyphonic .
En conséquence, la banque d'oscillateurs est le même nœud AudioKit que nous avons examiné précédemment. Sa sortie peut être envoyée à des mélangeurs, des enveloppes ou tout autre filtre et effet. Le protocole
AKPolyphonic décrit comment jouer des notes sur une note polyphonique; considérons-le plus en détail.
Afin de tester notre oscillateur, nous avons besoin d'un moyen de jouer plusieurs notes à la fois. Ce n'est pas du tout difficile!
Ajoutez le code suivant à la liste de lecture et assurez-vous que la vue en direct est ouverte:
class LiveView: AKLiveViewController, AKKeyboardDelegate { override func viewDidLoad() { let keyboard = AKKeyboardView(width: 440, height: 100) addView(keyboard) } } PlaygroundPage.current.liveView = LiveView() PlaygroundPage.current.needsIndefiniteExecution = true
Lorsque le terrain de jeu se compile, vous verrez ce qui suit:
Cool, hein? Le clavier musical est juste dans la cour de récréation!
AKKeyboardView est un autre utilitaire d'AudioKit qui permet d'explorer facilement les possibilités du framework. Appuyez sur les touches et vous constaterez qu'ils ne font aucun bruit.
Mettez à jour la
setUp votre
PlaygroundView avec les éléments suivants:
let keyboard = AKKeyboardView(width: 440, height: 100) keyboard.delegate = self addView(keyboard)
Cela fera de notre
PlaygroundView un délégué clavier et vous permettra de répondre aux frappes.
Mettez à jour la déclaration de classe comme suit:
class LiveView: AKLiveViewController, AKKeyboardDelegate
Ajoutez également quelques méthodes juste après la
setUp :
func noteOn(note: MIDINoteNumber) { bank.play(noteNumber: note, velocity: 80) } func noteOff(note: MIDINoteNumber) { bank.stop(noteNumber: note) }
Chaque fois que vous appuyez sur une touche, la méthode
noteOn est
noteOn , elle ne fait que dire à la banque d'oscillateurs de commencer à jouer la note, respectivement, dans la méthode
noteOff , la
noteOff s'arrête de jouer.
Tenez la souris et glissez les touches, vous entendrez un beau crescendo (un terme musical pour une augmentation progressive de la puissance sonore). La banque d'oscillateurs contient déjà un effet ADSR intégré, par conséquent l'atténuation d'une note est mélangée avec l'attaque de la suivante et sonne plutôt bien.
Vous avez peut-être remarqué que les notes qui nous ont donné les clés ne sont pas sous forme de fréquence. Ils sont déclarés comme
MIDINoteNumber . Si vous accédez à une annonce de ce type, vous verrez ce qui suit:
public typealias MIDINoteNumber = Int
MIDI signifie Musical Instrument Digital Interface. Il s'agit d'un format très répandu pour l'interaction des instruments de musique entre eux. Les numéros de note correspondent aux notes sur un clavier musical standard. Le deuxième paramètre - cette vitesse (vitesse) correspond à la force du coup sur la touche. Plus la valeur est basse, plus le toucher de la touche est doux, plus le son final est silencieux.
À la fin, vous devez activer le mode polyphonique sur les touches. Ajoutez le code suivant à la méthode
setUp :
keyboard.polyphonicMode = true
Maintenant, vous pouvez jouer plusieurs notes en même temps, comme indiqué dans l'image:
Au fait, c'est en do majeur :)
AudioKit a commencé son histoire il y a longtemps. Aujourd'hui, il utilise
Soundpipe et le code de
Csound (un projet du MIT qui a été lancé en 1985). Étonnamment, le code que nous lançons maintenant dans les terrains de jeux et que nous ajoutons à l'iPhone a été écrit il y a près de 30 ans.
Échantillonnage
Les techniques de synthèse sonore que nous avons explorées précédemment tentent de recréer un son réaliste à l'aide de blocs de base simples: oscillateurs, filtres et mélangeurs. Au début des années 1970, le développement des capacités informatiques a conduit à l'émergence d'une nouvelle approche - l'échantillonnage du son, dont le but est de créer une copie numérique du son.
L'échantillonnage est une technologie assez simple similaire à la photographie numérique. Lors de l'échantillonnage à intervalles réguliers, l'amplitude des ondes sonores est enregistrée:
Deux paramètres affectent la précision de l'enregistrement du son:
- Profondeur de bits : ou profondeur de bits, le nombre de niveaux de volume individuels que l'échantillonneur peut jouer
- Fréquence d'échantillonnage : ou fréquence d'échantillonnage, indique la fréquence à laquelle les mesures d'amplitude sont prises. Mesuré en hertz.
Explorons ces propriétés dans un nouveau terrain de jeu. Créez une nouvelle page et nommez-la «Samples». Remplacez le code généré par ce qui suit:
import AudioKitPlaygrounds import AudioKit import PlaygroundSupport let file = try AKAudioFile(readFileName: "climax-disco-part2.wav", baseDir: .resources) let player = try AKAudioPlayer(file: file) player.looping = true
Le code ci-dessus charge l'échantillon, crée un lecteur audio et le met en lecture sans fin.
Une archive avec un fichier WAV pour ce tutoriel est disponible
ici . Téléchargez-le et décompressez dans le dossier Ressources de votre aire de jeux.
Ajoutez ensuite le code suivant à la fin de l'aire de jeux:
AudioKit.output = player try AudioKit.start() player.play() PlaygroundPage.current.needsIndefiniteExecution = true
Cela connectera votre lecteur audio à AudioKit, il vous suffit d'augmenter le volume et d'en profiter!
, .
MP3-, , , . :
let bitcrusher = AKBitCrusher(player) bitcrusher.bitDepth = 16 bitcrusher.sampleRate = 40000
AudioKit:
AudioKit.output = bitcrusher
. , .
AKBitCrusher — AudioKit, . , , ZX Spectrum BBC Micro. , .
, (. delay). ,
AKBitCrusher . :
let delay = AKDelay(player) delay.time = 0.1 delay.dryWetMix = 1
0.1 .
dryWetMix . 1 , .
:
let leftPan = AKPanner(player, pan: -1) let rightPan = AKPanner(delay, pan: 1)
AKPanner , - . .
AudioKit. ,
AKBitCrusher AudioKit :
let mix = AKMixer(leftPan, rightPan) AudioKit.output = mix
, , .
Et ensuite?
AudioKit. , -, , , . , , .
.