Comme certains l'ont fait remarquer dans les commentaires, il convient d'examiner les points suivants PCM audio .
En bref, son est une onde qui se propage dans l'air. Afin de capturer ce son, nous utilisons un microphone qui contient une membrane qui vibre lorsque les ondes sonores l'atteignent. Cette vibration est traduite en un signal électrique, dont la tension monte et descend. Cette variation de tension est ensuite transformée en un signal numérique par un convertisseur analogique-numérique (ADC) en échantillonnant un certain nombre de fois par seconde (" taux d'échantillonnage "Le signal de sortie est un signal de sortie de 44 KHz (ou 44 100 échantillons par seconde) et, dans le cas présent, il est stocké sous forme de données audio modulées par code d'impulsions (PCM).
A orateur fonctionne en sens inverse ; le signal PCM est converti en signal analogique par une convertisseur numérique-analogique (DAC), puis le signal analogique est transmis au haut-parleur où il fait vibrer une membrane qui produit des vibrations dans l'air, ce qui se traduit par un son.
Manipulation de l'audio
Il existe de nombreuses bibliothèques pour de nombreux langages avec lesquels vous pouvez manipuler l'audio. Cependant, vous avez marqué cette question comme "agnostique", je vais mentionner quelques moyens simples (car c'est tout ce que je connais !) qui vous permettront de manipuler l'audio dans votre langue préférée.
Je présenterai les exemples de code en pseudocode.
Dans le pseudocode, chaque échantillon audio aura une amplitude comprise entre -1 et 1. Cela dépendra du type de données que vous utilisez pour stocker chaque échantillon. (Je n'ai pas eu affaire à des données float (il se peut donc que ce soit différent).
Amplification
Afin d'amplifier le son (et donc d'en augmenter le volume), il faut que la vibration des haut-parleurs soit plus importante pour que la magnitude de l'onde sonore soit plus élevée.
Pour que le haut-parleur bouge davantage, il faut augmenter la valeur de chaque échantillon :
original_samples = [0, 0.5, 0, -0.5, 0]
def amplify(samples):
foreach s in samples:
s = s * 2
amplified_samples = amplify(original_samples)
// result: amplified_samples == [0, 1, 0, -1, 0]
Les échantillons résultants sont maintenant amplifiés par 2 et, à la lecture, le son devrait être beaucoup plus fort qu'auparavant.
Le silence
Lorsqu'il n'y a pas de vibrations, il n'y a pas de sons. Le silence peut être obtenu en ramenant chaque échantillon à 0 ou à une valeur spécifique, mais il n'y a pas de changement d'amplitude entre les échantillons :
original_samples = [0, 0.5, 0, -0.5, 0]
def silence(samples):
foreach s in samples:
s = 0
silent_samples = silence(original_samples)
// result: silent_samples == [0, 0, 0, 0, 0]
La lecture de ce qui précède ne devrait produire aucun son, car la membrane du haut-parleur ne bouge pas du tout, en raison de l'absence de changement d'amplitude dans les échantillons.
Augmentation et diminution de la vitesse
Il existe deux façons d'accélérer les choses : (1) en modifiant la fréquence d'échantillonnage de la lecture ou (2) en modifiant les échantillons eux-mêmes.
Le passage de la fréquence d'échantillonnage de 44100 Hz à 22050 Hz diminue la vitesse de lecture de 2, ce qui rend le son plus lent et plus grave. Si l'on part d'une source de 22 kHz et qu'on la lit à 44 kHz, le son sera très rapide et aigu, comme le gazouillis des oiseaux.
La modification des échantillons eux-mêmes (et le maintien d'un taux d'échantillonnage de lecture constant) signifie que des échantillons (a) sont éliminés ou (b) sont ajoutés.
Pour accélérer la lecture de l'audio, jeter des échantillons :
original_samples = [0, 0.1, 0.2, 0.3, 0.4, 0.5]
def faster(samples):
new_samples = []
for i = 0 to samples.length:
if i is even:
new_samples.add(samples[i])
return new_samples
faster_samples = faster(original_samples)
// result: silent_samples == [0, 0.2, 0.4]
Le résultat du programme ci-dessus est que l'audio sera accéléré par un facteur de 2, comme si vous lisiez un audio échantillonné à 22 KHz à 44 KHz.
Ralentir la lecture de l'audio, ajouter quelques échantillons :
original_samples = [0, 0.1, 0.2, 0.3]
def slower(samples):
new_samples = []
for i = 0 to samples.length:
new_samples.add(samples[i])
new_samples.add(interpolate(s[i], s[i + 1]))
return new_samples
slower_samples = slower(original_samples)
// result: silent_samples == [0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3]
Ici, des échantillons supplémentaires ont été ajoutés, ralentissant ainsi la lecture. Ici, nous avons un interpolation qui fait une "supposition" sur la manière de remplir l'espace supplémentaire qui doit être ajouté.
Analyse du spectre et modification des sons par FFT
En utilisant une technique appelée Transformée de Fourier rapide (FFT), les données sonores dans le domaine amplitude-temps peuvent être mises en correspondance avec le domaine fréquence-temps pour découvrir les composantes de fréquence de l'audio. Ceci peut être utilisé pour produire le analyseurs de spectre que vous pouvez voir sur votre lecteur audio préféré.
De plus, comme vous disposez maintenant des composantes de fréquence de l'audio, si vous modifiez la quantité de
Si vous souhaitez couper certaines fréquences, vous pouvez utiliser la FFT pour transformer les données sonores dans le domaine fréquence-temps et supprimer les composantes de fréquence qui ne sont pas souhaitées. C'est ce qu'on appelle la filtrage .
_Faire un filtre passe-haut_ qui permet d'obtenir des fréquences supérieures à une certaine fréquence peut être effectuée de la manière suivante :
data = fft(orignal_samples)
for i = (data.length / 2) to data.length:
data[i] = 0
new_samples = inverse_fft(data)
Dans l'exemple ci-dessus, toutes les fréquences supérieures à la moitié de l'échelle sont coupées. Ainsi, si N- .)
I
data = fft(orignal_samples)
for i = 0 to (data.length / 4):
increase(data[i])
new_samples = inverse_fft(data)
T
T
