Geluidsinvoer vastleggen

De klasse Microphone heeft geen constructormethode. In plaats daarvan gebruikt u de statische methode Microphone.getMicrophone() om een nieuwe instantie Microphone te verkrijgen, zoals hieronder wordt weergegeven:

var mic:Microphone = Microphone.getMicrophone();

Als de methode Microphone.getMicrophone() zonder parameter wordt aangeroepen, wordt het eerste geluidsinvoerapparaat geretourneerd dat op het systeem van de gebruiker wordt gedetecteerd.

Er kan meer dan één geluidsinvoerapparaat op een systeem aangesloten zijn. Uw toepassing kan de eigenschap Microphone.names gebruiken om een array met de namen van alle beschikbare geluidsinvoerapparaten op te vragen. Vervolgens kan de toepassing de methode Microphone.getMicrophone() aanroepen, waarbij de parameter index overeenkomt met de indexwaarde van de naam van een apparaat in de array.

Het is mogelijk dat er geen microfoon of ander geluidsinvoerapparaat op een systeem is aangesloten. U kunt de eigenschap Microphone.names of de methode Microphone.getMicrophone() gebruiken om na te gaan of de gebruiker een geluidsinvoerapparaat heeft geïnstalleerd. Als de gebruiker geen geluidsinvoerapparaat heeft geïnstalleerd, heeft de array names een lengte van nul, en retourneert de methode getMicrophone() de waarde null .

Wanneer uw toepassing de methode Microphone.getMicrophone() aanroept, wordt in Flash Player het dialoogvenster Flash Player Settings weergegeven, waarin de gebruiker wordt gevraagd om Flash Player al dan niet toegang tot de camera en microfoon op het systeem te verlenen. Nadat de gebruiker in dit dialoogvenster op de knop Allow of de knop Deny heeft geklikt, wordt de gebeurtenis StatusEvent verzonden. De eigenschap code van die StatusEvent-instantie geeft aan of microfoontoegang wordt toegestaan dan wel geblokkeerd, zoals wordt weergegeven in dit voorbeeld:

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."); 
    } 
}

De eigenschap StatusEvent.code bevat de waarde Microphone.Unmuted als er toegang wordt verleend, en Microphone.Muted als toegang wordt geweigerd.

De eigenschap Microphone.muted wordt respectievelijk op true of false ingesteld wanneer de gebruiker microfoontoegang toestaat of blokkeert. De eigenschap muted wordt echter pas voor de instantie Microphone ingesteld nadat de gebeurtenis StatusEvent is verzonden, zodat uw toepassing ook moet wachten tot de gebeurtenis StatusEvent.STATUS is verzonden alvorens de waarde van de eigenschap Microphone.muted op te vragen.

Flash Player kan het instellingenvenster alleen weergeven als het toepassingsvenster groot genoeg is (minimaal 215 x 138 pixels). Anders wordt de toegang automatisch geweigerd.

Voor in de AIR-toepassingssandbox uitgevoerde inhoud is geen toestemming van de gebruiker nodig om de microfoon te benaderen. Er worden dus nooit statusgebeurtenissen voor het dempen en dempen ongedaan maken van de microfoon verzonden. Voor in AIR buiten de toepassingssandbox uitgevoerde inhoud is wel toestemming van de gebruiker nodig en deze statusgebeurtenissen kunnen dus worden verzonden.

Audio-invoer van een microfoon kan naar de lokale systeemluidsprekers worden geleid door de methode Microphone.setLoopback() met parameterwaarde true aan te roepen.

Wanneer geluid uit een lokale microfoon naar lokale luidsprekers wordt geleid, zou een audiofeedbacklus kunnen ontstaan, waardoor harde piepgeluiden worden afgegeven en de geluidshardware beschadigd kan raken. Als de methode Microphone.setUseEchoSuppression() met parameterwaarde true wordt aangeroepen, wordt de kans op audiofeedback kleiner, maar blijft aanwezig. Het wordt aanbevolen om Microphone.setUseEchoSuppression(true) altijd aan te roepen voordat Microphone.setLoopback(true) wordt aangeroepen, tenzij u er zeker van bent dat de gebruiker het geluid via een hoofdtelefoon of andere apparatuur dan luidsprekers afspeelt.

In de volgende code ziet u hoe u de audio van een lokale microfoon naar de lokale systeemluidsprekers kunt leiden:

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

Uw toepassing kan de audiogegevens die uit een microfoon afkomstig zijn, op twee manieren aanpassen. Ten eerste kan de versterking van het invoergeluid worden gewijzigd, waarbij in feite de invoerwaarden met een opgegeven factor worden vermenigvuldigd om een harder of zachter geluid te bereiken. De eigenschap Microphone.gain accepteert numerieke waarden van 0 tot en met 100. De waarde 50 fungeert als vermenigvuldigingsfactor 1, waarmee het basisvolume wordt opgegeven. De waarde 0 fungeert als vermenigvuldigingsfactor 0, waarmee de invoeraudio volledig wordt gedempt. Bij waarden van meer dan 50 wordt het volume verhoogd.

Uw toepassing kan ook de bemonsteringsfrequentie van de invoeraudio wijzigen. Hogere bemonsteringsfrequenties corresponderen met hogere geluidskwaliteit, maar leiden ook tot zwaardere gegevensstreams die meer resources voor overdracht en opslag gebruiken. De eigenschap Microphone.rate vertegenwoordigt de audiobemonsteringsfrequentie gemeten in kilohertz (kHz). De standaardbemonsteringsfrequentie is 8 kHz. U kunt de eigenschap Microphone.rate op een hogere waarde dan 8 kHz instellen als uw microfoon de hogere frequentie ondersteunt. Als de eigenschap Microphone.rate bijvoorbeeld op 11 wordt ingesteld, wordt de samplingfrequentie ingesteld op 11 kHz; bij een waarde van 22 wordt de samplingfrequentie ingesteld op 22 kHz enzovoort. Welke samplingfrequenties beschikbaar zijn, is afhankelijk van de geselecteerde codec. Wanneer u de codec Nellymoser gebruikt, kunt u 5, 8, 11, 16, 22 en 44 kHz opgeven als samplingfrequentie. Wanneer u Speex-codec gebruikt (beschikbaar vanaf Flash Player 10 en Adobe AIR 1.5), bent u beperkt tot 16 kHz.

Om bandbreedte en verwerkingsresources te besparen, probeert Flash Player na te gaan wanneer er geen geluid door een microfoon wordt overgebracht. Wanneer het activiteitsniveau van de microfoon gedurende een bepaalde tijdsperiode onder het stiltedrempelniveau blijft, stopt Flash Player met de overdracht van audio-invoer en wordt in plaats daarvan de eenvoudige gebeurtenis ActivityEvent verzonden. Als u de Speex-codec gebruikt (beschikbaar in Flash Player 10 of hoger en Adobe AIR 1.5 of hoger), stelt u het stilteniveau in op 0 om ervoor te zorgen dat de toepassing continu audiogegevens overzendt. Bij de detectie van Speex-spraakactiviteit wordt de bandbreedte automatisch gereduceerd.

Drie eigenschappen van de klasse Microphone volgen en controleren de activiteitsdetectie:

• De alleen-lezen-eigenschap activityLevel vertegenwoordigt de hoeveelheid geluid die door de microfoon wordt gedetecteerd, op een schaal van 0 tot 100.

• Via de eigenschap silenceLevel wordt opgegeven hoeveel geluid nodig is om de microfoon te activeren en de gebeurtenis ActivityEvent.ACTIVITY te verzenden. Ook voor de eigenschap silenceLevel wordt een schaal van 0 tot 100 gebruikt; de standaardwaarde is 10.

• Met de eigenschap silenceTimeout wordt opgegeven gedurende hoeveel milliseconden het activiteitsniveau onder het stilteniveau moet blijven voordat de gebeurtenis ActivityEvent.ACTIVITY wordt verzonden ter indicatie dat er nu geen geluid uit de microfoon komt. De standaardwaarde voor silenceTimeout is 2000.

Zowel de eigenschap Microphone.silenceLevel als de eigenschap Microphone.silenceTimeout is alleen-lezen, maar de waarden van deze eigenschappen kunnen worden gewijzigd via de methode Microphone.setSilenceLevel() .

In sommige gevallen kan het proces ter activering van de microfoon bij detectie van nieuwe activiteit tot een korte vertraging leiden. Dergelijke activeringsvertragingen kunnen worden voorkomen door de microfoon altijd actief te houden. Uw toepassing kan de methode Microphone.setSilenceLevel() met de parameter silenceLevel ingesteld op nul gebruiken om Flash Player de opdracht te geven om de microfoon actief te houden, zelfs als er geen geluid wordt gedetecteerd. Als de parameter silenceLevel daarentegen op 100 wordt ingesteld, kan de microfoon helemaal niet worden geactiveerd.

In het volgende voorbeeld wordt informatie over de microfoon weergegeven en wordt melding gemaakt van activiteitsgebeurtenissen en statusgebeurtenissen die door een object Microphone worden verzonden:

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); 
}

Wanneer u het bovenstaande voorbeeld uitvoert, moet u spreken of andere geluiden maken in uw systeemmicrofoon en de instructies trace bekijken die worden weergegeven in een console- of foutopsporingsvenster.

Er zijn aanvullende audiomogelijkheden beschikbaar bij gebruik van ActionScript met een streaming-mediaserver zoals Flash Media Server.

Zo kan uw toepassing bijvoorbeeld een object Microphone aan een object NetStream koppelen en gegevens rechtstreeks van de microfoon van de gebruiker naar de server verzenden. Audiogegevens kunnen ook van de server worden gestreamd naar een toepassing die is gemaakt met Flash of Flex, en worden afgespeeld als onderdeel van een filmfragment of door gebruik te maken van een Video-object.

De Speex-codec is beschikbaar vanaf Flash Player 10 en Adobe AIR 1.5. Stel de eigenschap codec van het Microphone-object in om de codec in te stellen die wordt gebruikt voor gecomprimeerde audio die naar de mediaserver is verzonden. Deze eigenschap kan twee waarden hebben die worden opgesomd in de klasse SoundCodec. Stel de eigenschap codec in op SoundCodec.SPEEX als u de codec Speex wilt selecteren voor de compressie van geluid. Stel de eigenschap codec in op SoundCodec.NELLYMOSER (standaardwaarde) als u de codec Nellymoser wilt selecteren voor de compressie van geluid.

Zie de onlinedocumentatie bij Flash Media Server op www.adobe.com/go/learn_fms_docs_nl voor meer informatie.

In Flash Player 10.1. en AIR 2 of later kunt u geluidsgegevens van een microfoon vastleggen als een bytearray of als zwevende-kommawaarden. Elke waarde vertegenwoordigt een sample van homofone audiogegevens.

Als u microfoongegevens wilt opvragen, stel u een gebeurtenislistener in voor de gebeurtenis sampleData van het Microphone-object. Het Microphone-object verzendt periodiek sampleData -gebeurtenissen, terwijl de microfoonbuffer wordt gevuld met geluidssamples. Het SampleDataEvent-object heeft een data -eigenschap die bestaat uit een bytearray van geluidssamples. Deze samples worden allemaal vertegenwoordigd als zwevende-kommawaarden, die elk een homofoon geluidssample zijn.

In de volgende code worden geluidsgegevens van een microfoon vastgelegd in een ByteArray-object met de naam 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); 
    } 
}

U kunt de samplebytes hergebruiken als audio die kan worden afgespeeld voor een Sound-object. Als u dit doet, moet u de eigenschap rate van het Microphone-object op 44 instellen. Dit is de samplingfrequentie die wordt gebruikt door Sound-objecten. (Microfoonsamples die zijn vastgesteld met een frequentie die lager ligt dan de 44 kHz die wordt vereist door het Sound-object, kunnen worden geconverteerd.) Denk er ook aan dat het Microphone-object homofone samples vastlegt, terwijl het Sound-object stereogeluid gebruikt. Dit betekent dat u elke byte die door het Microphone-object wordt vastgelegd, twee keer naar het Sound-object moet schrijven. In het volgende voorbeeld worden 4 seconden aan geluidsgegevens van een microfoon vastgelegd en worden deze gegevens met een Sound-object afgespeeld:

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."); 
}

Zie Werken met dynamisch gegenereerde audio voor meer informatie over het afspelen van geluiden van geluidssamplegegevens.