Capture de l’entrée de son

Flash Player 9 et les versions ultérieures, Adobe AIR 1.0 et les versions ultérieures

La classe Microphone permet à votre application de se connecter à un microphone ou à un autre périphérique d’entrée de son sur le système de l’utilisateur et de diffuser l’audio sur les haut-parleurs de ce système ou d’envoyer les données audio à un serveur distant (Flash Media Server, par exemple). Vous pouvez accéder aux données audio brutes à partir du microphone, puis les enregistrer ou les traiter. Vous pouvez également envoyer directement l’audio aux haut-parleurs du système ou envoyer des données audio compressées à un serveur distant. Pour envoyer des données à un serveur distant, vous pouvez utiliser le codec Speex ou Nellymoser (le codec Speex est pris en charge depuis Flash Player version 10 et Adobe AIR version 1.5).

Accès à un microphone

La classe Microphone ne possède pas de méthode constructeur. A la place, vous utilisez la méthode statique Microphone.getMicrophone() pour obtenir une nouvelle occurrence de Microphone, comme indiqué ci-dessous :

var mic:Microphone = Microphone.getMicrophone();

Lorsque vous appelez la méthode Microphone.getMicrophone() sans paramètre, le premier périphérique d’entrée de son détecté sur le système de l’utilisateur est renvoyé.

Un système peut avoir plusieurs périphériques d’entrée de son qui lui sont associés. Votre application peut utiliser la propriété Microphone.names pour obtenir un tableau des noms de tous les périphériques d’entrée de son disponibles. Elle peut ensuite appeler la méthode Microphone.getMicrophone() avec un paramètre index qui correspond à la valeur d’index du nom d’un périphérique dans le tableau.

Il se peut qu’un système n’ait aucun microphone ni périphérique d’entrée de son qui lui soit associé. Vous pouvez utiliser la propriété Microphone.names ou la méthode Microphone.getMicrophone() pour vérifier si l’utilisateur a installé un périphérique d’entrée de son. Si ce n’est pas le cas, la longueur du tableau names est zéro, et la méthode getMicrophone() renvoie une valeur null .

Lorsque votre application appelle la méthode Microphone.getMicrophone() , Flash Player affiche la boîte de dialogue des paramètres de Flash Player, qui invite l’utilisateur à autoriser ou à refuser l’accès Flash Player à la caméra et au microphone sur le système. Une fois que l’utilisateur a fait son choix dans cette boîte de dialogue, un StatusEvent est envoyé. La propriété code de cette occurrence de StatusEvent indique si l’accès au microphone a été autorisé ou refusé, comme indiqué dans cet exemple :

import flash.media.Microphone; 
 
var mic:Microphone = Microphone.getMicrophone(); 
mic.addEventListener(StatusEvent.STATUS, this.onMicStatus); 
 
function onMicStatus(event:StatusEvent):void 
{ 
    if (event.code == "Microphone.Unmuted") 
    { 
        trace("Microphone access was allowed."); 
    }  
    else if (event.code == "Microphone.Muted") 
    { 
         trace("Microphone access was denied."); 
    } 
}

La propriété StatusEvent.code contiendra Microphone.Unmuted si l’accès a été autorisé, ou Microphone.Muted s’il a été refusé.

la propriété Microphone.muted est définie sur true ou sur false lorsque l’utilisateur autorise ou refuse l’accès au microphone, respectivement. Néanmoins, la propriété muted n’est pas définie sur l’occurrence de Microphone tant que StatusEvent n’a pas été distribué. Par conséquent, l’application doit également attendre la distribution de l’événement StatusEvent.STATUS avant de vérifier la propriété Microphone.muted .

Pour que Flash Player affiche la boîte de dialogue de paramétrage, la taille de la fenêtre de l’application doit être suffisamment élevée (215 sur 138 pixels au moins). Dans le cas contraire, l’accès est automatiquement refusé.

Un contenu qui s’exécute dans le sandbox de l’application AIR ne nécessite pas l’autorisation de l’utilisateur pour accéder au microphone. Par conséquent, les événements d’état associés à l’activation et à la désactivation du microphone ne sont jamais distribués. Etant donné qu’un contenu qui s’exécute dans AIR en dehors du sandbox de l’application ne nécessite pas l’autorisation de l’utilisateur, il est possible de distribuer ces événements d’état.

Acheminement de l’audio du microphone vers des haut-parleurs locaux

L’entrée audio issue d’un microphone peut être acheminée vers les haut-parleurs du système local en appelant la méthode Microphone.setLoopback() avec une valeur de paramètre true .

Lorsque le son provenant d’un microphone local est acheminé vers des haut-parleurs locaux, vous risquez de créez une boucle de réaction acoustique pouvant entraîner des grincements d’une grande intensité et endommager ainsi votre matériel. Vous pouvez appeler la méthode Microphone.setUseEchoSuppression() avec une valeur de paramètre true pour réduire (sans éliminer complètement) le risque de réaction acoustique. Adobe vous conseille de toujours appeler Microphone.setUseEchoSuppression(true) avant d’appeler Microphone.setLoopback(true) , à moins que vous soyez sûr que l’utilisateur lit le son à l’aide d’un casque ou d’un dispositif autre que les haut-parleurs.

Le code suivant indique comment acheminer l’audio d’un microphone local vers les haut-parleurs du système local :

var mic:Microphone = Microphone.getMicrophone(); 
mic.setUseEchoSuppression(true); 
mic.setLoopBack(true);

Modification de l’audio du microphone

Votre application peut modifier les données audio provenant d’un microphone de deux façons différentes. Premièrement, elle peut modifier le gain du son entré, qui multiplie les valeurs d’entrée par une quantité spécifiée pour créer un son plus ou moins intense. La propriété Microphone.gain accepte des valeurs numériques comprises entre 0 et 100 inclus. Une valeur de 50 a un rôle de multiplicateur de un et spécifie un volume normal. Une valeur de zéro agit comme un multiplicateur de zéro et interrompt l’audio d’entrée. Les valeurs supérieures à 50 indiquent un volume supérieur à la normale.

Votre application peut également modifier la fréquence d’échantillonnage de l’audio d’entrée. Des fréquences d’échantillonnage supérieures augmentent la qualité du son, mais créent également des flux de données plus denses qui utilisent davantage de ressources pour la transmission et le stockage. La propriété Microphone.rate représente la fréquence d’échantillonnage audio mesurée en kilohertz (kHz). La fréquence d’échantillonnage par défaut est de 8 kHz. Vous pouvez définir la propriété Microphone.rate sur une valeur supérieure à 8 kHz si votre microphone prend en charge la fréquence supérieure. Par exemple, si vous définissez la propriété Microphone.rate sur la valeur 11, la fréquence d’échantillonnage est réglée sur 11 kHz ; si vous la définissez sur 22, la fréquence d’échantillonnage est réglée sur 22 kHz, et ainsi de suite. Les fréquences d’échantillonnage disponibles varient en fonction du codec sélectionné. Lorsque vous utilisez le codec Nellymoser, vous pouvez spécifier les fréquences d’échantillonnage 5, 8, 11, 16, 22 et 44 kHz. Lorsque vous utilisez le codec Speex (disponible à partir de Flash Player 10 et Adobe AIR 1.5), vous ne pouvez utiliser que 16 kHz.

Détection de l’activité du microphone

Pour économiser les ressources de traitement et de bande passante, Flash Player tente de détecter lorsque aucun son n’est transmis par un microphone. Lorsque le niveau d’activité du microphone se situe sous le seuil de niveau de silence pendant longtemps, Flash Player arrête la transmission de l’entrée audio et envoie un simple événement ActivityEvent à la place. Si vous utilisez le codec Speex (disponible dans Flash Player 10 et versions ultérieures, ainsi que dans Adobe AIR 1.5 et versions ultérieures), définissez le niveau de silence sur 0 afin de vous assurer que l’application transmet les données audio en continu. La fonction de détection d’activité vocale de Speex réduit automatiquement la bande passante.

Remarque : un objet Microphone ne distribue des événements Activity que si l’application contrôle actuellement le microphone. Par conséquent, si vous n’appelez pas setLoopBack( true ) , que vous n’associez pas d’écouteur aux événements de données d’exemple ou que vous ne connectez pas le microphone à un objet NetStream, aucun événement d’activité n’est distribué.

Trois propriétés de la classe Microphone surveillent et contrôlent la détection d’activité :

  • La propriété activityLevel en lecture seule indique la quantité de son détectée par le microphone, sur une échelle de 0 à 100.

  • La propriété silenceLevel spécifie la quantité de son nécessaire pour activer le microphone et envoie un événement ActivityEvent.ACTIVITY . La propriété silenceLevel utilise également une échelle de 0 à 100, et la valeur par défaut est 10.

  • La propriété silenceTimeout décrit le nombre de millisecondes pendant lequel le niveau d’activité doit rester sous le niveau de silence, jusqu’à ce qu’un événement ActivityEvent.ACTIVITY soit envoyé pour indiquer que le microphone est maintenant désactivé. La valeur silenceTimeout par défaut est 2000.

Les propriétés Microphone.silenceLevel et Microphone.silenceTimeout sont en lecture seule, mais vous pouvez modifier leurs valeurs à l’aide de la méthode Microphone.setSilenceLevel() .

Dans certains cas, l’activation du microphone alors qu’une nouvelle activité est détectée peut entraîner un court délai. Vous pouvez laisser le microphone actif en permanence pour supprimer ces délais d’activation. Votre application peut appeler la méthode Microphone.setSilenceLevel() avec le paramètre silenceLevel défini sur zéro pour indiquer à Flash Player de laisser le microphone actif et de continuer à rassembler des données audio, même lorsque aucun son n’est détecté. Inversement, lorsque vous définissez le paramètre silenceLevel sur 100, le microphone n’est pas activé.

L’exemple suivant affiche les informations relatives au microphone et aux événements activity et status envoyés par un objet Microphone :

import flash.events.ActivityEvent; 
import flash.events.StatusEvent; 
import flash.media.Microphone; 
 
var deviceArray:Array = Microphone.names; 
trace("Available sound input devices:"); 
for (var i:int = 0; i < deviceArray.length; i++) 
{ 
    trace(" " + deviceArray[i]); 
} 
 
var mic:Microphone = Microphone.getMicrophone(); 
mic.gain = 60; 
mic.rate = 11; 
mic.setUseEchoSuppression(true); 
mic.setLoopBack(true); 
mic.setSilenceLevel(5, 1000); 
     
mic.addEventListener(ActivityEvent.ACTIVITY, this.onMicActivity); 
mic.addEventListener(StatusEvent.STATUS, this.onMicStatus); 
     
var micDetails:String = "Sound input device name: " + mic.name + '\n'; 
micDetails += "Gain: " + mic.gain + '\n'; 
micDetails += "Rate: " + mic.rate + " kHz" + '\n'; 
micDetails += "Muted: " + mic.muted + '\n'; 
micDetails += "Silence level: " + mic.silenceLevel + '\n'; 
micDetails += "Silence timeout: " + mic.silenceTimeout + '\n'; 
micDetails += "Echo suppression: " + mic.useEchoSuppression + '\n'; 
trace(micDetails); 
 
function onMicActivity(event:ActivityEvent):void 
{ 
    trace("activating=" + event.activating + ", activityLevel=" +  
        mic.activityLevel); 
} 
 
function onMicStatus(event:StatusEvent):void 
{ 
    trace("status: level=" + event.level + ", code=" + event.code); 
}

Lorsque vous exécutez l’exemple ci-dessus, parlez ou faites du bruit dans votre microphone système et observez les instructions trace qui apparaissent dans une console ou une fenêtre de débogage.

Envoi d’audio vers et depuis une passerelle multimédia

D’autres fonctionnalités audio sont disponibles lorsque vous utilisez ActionScript avec une passerelle multimédia de diffusion en continu telle que Flash Media Server.

Votre application peut notamment associer un objet Microphone à un objet NetStream et transmettre directement des données du microphone de l’utilisateur au serveur. Les données audio peuvent également être diffusées en continu du serveur vers une application et lues dans le cadre d’un MovieClip ou au moyen d’un objet Video.

Le codec Speex est pris en charge depuis Flash Player version 10 et Adobe AIR version 1.5. Pour définir le codec utilisé pour les données audio compressées envoyées au serveur multimédia, définissez la propriété codec de l’objet Microphone. Cette propriété gère deux valeurs, qui sont énumérées dans la classe SoundCodec. La définition de la propriété codec sur SoundCodec.SPEEX sélectionne le codec Speex pour la compression audio. La définition de la propriété codec sur SoundCodec.NELLYMOSER (valeur par défaut) sélectionne le codec Nellymoser pour la compression audio.

Pour plus d’informations, voir la documentation de Flash Media Server disponible en ligne à l’adresse suivante : www.adobe.com/go/learn_fms_docs_fr .

Capture des données audio issues d’un microphone

Dans Flash Player 10.1 et AIR 2 ou ultérieur, vous pouvez capturer les données issues d’un microphone sous forme de tableau d’octets composé de valeurs à virgule flottante. Chaque valeur représente un échantillon de données audio monophoniques.

Pour obtenir les données issues d’un microphone, définissez un écouteur associé à l’événement sampleData de l’objet Microphone. L’objet Microphone distribue les événements sampleData à fréquence régulière au fur et à mesure que le tampon du microphone se remplit d’échantillons audio. La propriété data de l’objet SampleDataEvent correspond à un tableau d’octets d’échantillons audio. Les échantillons sont représentés par des valeurs à virgule flottante, chacune d’elles correspondant à un échantillon audio monophonique.

Le code suivant capture les données audio issues d’un microphone dans un objet ByteArray appelé soundBytes :

var mic:Microphone = Microphone.getMicrophone(); 
mic.setSilenceLevel(0, DELAY_LENGTH); 
mic.addEventListener(SampleDataEvent.SAMPLE_DATA, micSampleDataHandler); 
function micSampleDataHandler(event:SampleDataEvent):void { 
    while(event.data.bytesAvailable)     { 
        var sample:Number = event.data.readFloat(); 
        soundBytes.writeFloat(sample); 
    } 
}

Vous pouvez réutiliser les octets d’échantillon sous forme d’audio à lire d’un objet Sound. Pour ce faire, définissez la propriété rate de l’objet Microphone sur 44, à savoir la fréquence d’échantillonnage utilisée par les objets Sound. (Vous pouvez également convertir des échantillons issus de microphone capturés à une fréquence inférieure sur le taux 44 kHz requis par l’objet Sound.) N’oubliez pas non plus que l’objet Microphone capture des échantillons monophoniques, alors que l’objet Sound utilise un son stéréo. Ecrivez donc deux fois dans l’objet Sound chaque octet capturé par l’objet Microphone. L’exemple suivant capture 4 secondes de données issues d’un microphone et les lit par le biais d’un objet Sound :

const DELAY_LENGTH:int = 4000; 
var mic:Microphone = Microphone.getMicrophone(); 
mic.setSilenceLevel(0, DELAY_LENGTH); 
mic.gain = 100; 
mic.rate = 44; 
mic.addEventListener(SampleDataEvent.SAMPLE_DATA, micSampleDataHandler); 
 
var timer:Timer = new Timer(DELAY_LENGTH); 
timer.addEventListener(TimerEvent.TIMER, timerHandler); 
timer.start(); 
 
function micSampleDataHandler(event:SampleDataEvent):void 
{ 
    while(event.data.bytesAvailable) 
    { 
        var sample:Number = event.data.readFloat(); 
        soundBytes.writeFloat(sample); 
    } 
} 
var sound:Sound = new Sound(); 
var channel:SoundChannel; 
function timerHandler(event:TimerEvent):void 
{ 
    mic.removeEventListener(SampleDataEvent.SAMPLE_DATA, micSampleDataHandler); 
    timer.stop(); 
    soundBytes.position = 0; 
    sound.addEventListener(SampleDataEvent.SAMPLE_DATA, playbackSampleHandler); 
    channel.addEventListener( Event.SOUND_COMPLETE, playbackComplete ); 
    channel = sound.play(); 
} 
 
function playbackSampleHandler(event:SampleDataEvent):void 
{ 
    for (var i:int = 0; i < 8192 && soundBytes.bytesAvailable > 0; i++) 
    { 
        trace(sample); 
        var sample:Number = soundBytes.readFloat(); 
        event.data.writeFloat(sample); 
        event.data.writeFloat(sample); 
    } 
} 
 
function playbackComplete( event:Event ):void 
{ 
    trace( "Playback finished."); 
}

Pour plus d’informations sur la lecture de données d’échantillons audio, voir Utilisation de données audio générées de façon dynamique .