285
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
The following example alternates the panning of the sound from the left channel to the right channel and back while 
the sound plays:
var snd = new air.Sound();           
var req = new air.URLRequest("bigSound.mp3");  
snd.load(req);  
var panCounter = 0;  
var trans = new air.SoundTransform(1, 0);  
var channel = snd.play(0, 1, trans);  
channel.addEventListener(air.Event.SOUND_COMPLETE,   
onPlaybackComplete);  
var timer = setInterval(panner, 100);  
function panner()  
{  
trans.pan = Math.sin(panCounter);  
channel.soundTransform = trans; // or SoundMixer.soundTransform = trans;  
panCounter += 0.05;  
}  
function onPlaybackComplete(event)  
{  
clearInterval(timer);  
}
The code starts by loading a sound file and then creating a SoundTransform object with volume set to 1 (full volume) 
and pan set to 0 (evenly balanced between left and right). Then it calls the 
snd.play()
method, passing the 
SoundTransform object as a parameter. 
While the sound plays, the 
panner()
method executes repeatedly. The 
panner()
method uses the 
Math.sin()
function to generate a value between -1 and 1. This range corresponds to the acceptable values of the 
SoundTransform.pan
property. The SoundTransform object’s 
pan
property is set to the new value, and then the 
channel’s 
soundTransform
property is set to use the altered SoundTransform object.
To run this example, replace the filename bigSound.mp3 with the name of a local mp3 file. Then run the example. You 
should hear the left channel volume getting louder while the right channel volume gets softer, and vice versa.
In this example, the same effect could be achieved by setting the 
soundTransform
property of the SoundMixer class. 
However, that would affect the panning of all sounds currently playing, not just the single sound this SoundChannel 
object plays.
Working with sound metadata
Sound files that use the mp3 format can contain additional data about the sound in the form of ID3 tags. 
Not every mp3 file contains ID3 metadata. When a Sound object loads an mp3 sound file, it dispatches an 
Event.ID3
event if the sound file contains ID3 metadata. To prevent run-time errors, your application should wait to receive the 
Event.ID3
event before accessing the 
Sound.id3
property for a loaded sound.
The following code shows how to recognize when the ID3 metadata for a sound file has been loaded:
Pdf create bookmarks - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
add bookmarks to pdf preview; bookmarks pdf reader
Pdf create bookmarks - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmarks pdf; how to bookmark a pdf file in acrobat
286
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
var s = new air.Sound();  
s.addEventListener(air.Event.ID3, onID3InfoReceived);  
var urlReq = new air.URLRequest("mySound.mp3");  
s.load(urlReq);  
function onID3InfoReceived(event)  
{  
var id3 = event.target.id3;  
air.trace("Received ID3 Info:");  
for (propName in id3)  
 
air.trace(propName + " = " + id3[propName]);  
 
}
This code starts by creating a Sound object and telling it to listen for the 
id3
event. When the sound file’s ID3 metadata 
is loaded, the 
onID3InfoReceived()
method is called. The target of the Event object that is passed to the 
onID3InfoReceived()
method is the original Sound object. The method then gets the Sound object’s 
id3
property 
and iterates through its named properties to trace their values.
Accessing raw sound data
The 
SoundMixer.computeSpectrum()
method lets an application read the raw sound data for the waveform that is 
currently being played. If more than one SoundChannel object is currently playing, the 
SoundMixer.computeSpectrum()
method shows the combined sound data of every SoundChannel object mixed 
together.
How sound data is returned
The sound data is returned as a ByteArray object containing 512 four-byte sets of data, each of which represents a 
floating point value between -1 and 1. These values represent the amplitude of the points in the sound waveform being 
played. The values are delivered in two groups of 256, the first group for the left stereo channel and the second group 
for the right stereo channel.
The 
SoundMixer.computeSpectrum()
method returns frequency spectrum data rather than waveform data if the 
FFTMode
parameter is set to 
true
. The frequency spectrum shows amplitude arranged by sound frequency, from 
lowest frequency to highest. A Fast Fourier Transform (FFT) is used to convert the waveform data into frequency 
spectrum data. The resulting frequency spectrum values range from 0 to roughly 1.414 (the square root of 2).
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Bookmarks. inputFilePath = Program.RootPath + "\\" 3.pdf"; String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; 'create optimizing options
create bookmark pdf file; bookmarks in pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
how to split a PDF file into multiple ones by PDF bookmarks or outlines Valid value for each index: 1 to (Page Count - 1). ' Create output PDF file path
convert word to pdf with bookmarks; split pdf by bookmark
287
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
The following diagram compares the data returned from the 
computeSpectrum()
method when the 
FFTMode
parameter is set to 
true
and when it is set to 
false
. The sound used for this diagram contains a loud bass sound in 
the left channel and a drum hit sound in the right channel.
The 
computeSpectrum()
method can also return data that has been resampled at a lower bit rate. Generally, this 
results in smoother waveform data or frequency data at the expense of detail. The 
stretchFactor
parameter controls 
the rate at which the 
computeSpectrum()
method data is sampled. When the 
stretchFactor
parameter is set to 0, 
the default, the sound data is sampled at a rate of 44.1 kHz. The rate is halved at each successive value of the 
stretchFactor
parameter. So a value of 1 specifies a rate of 22.05 kHz, a value of 2 specifies a rate of 11.025 kHz, and 
so on. The 
computeSpectrum()
method still returns 256 floating point values per stereo channel when a higher 
stretchFactor
value is used. 
Building a simple sound visualizer
The following example uses the 
SoundMixer.computeSpectrum()
method to show a chart of the sound waveform 
that animates periodically:
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. inputFilePath = Program.RootPath + "\\" 3.pdf"; String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing options
bookmark pdf reader; add bookmarks to pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
copy pdf bookmarks to another pdf; pdf export bookmarks
288
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
<html>  
<title>Sound Spectrum</title>  
<script src="AIRAliases.js" />  
<script>  
const PLOT_WIDTH = 600;  
const CHANNEL_LENGTH = 256;  
var snd = new air.Sound();  
var req = new air.URLRequest("test.mp3");  
var bytes = new air.ByteArray();  
var divStyles = new Array;  
/**  
* Initializes the application. It draws 256 DIV elements to the document body,  
* and sets up a divStyles array that contains references to the style objects of   
* each DIV element. It then calls the playSound() function.  
*/  
function init()  
{  
var div;  
for (i = 0; i < CHANNEL_LENGTH; i++)  
{  
div = document.createElement("div");  
div.style.height = "1px";   
div.style.width = "0px";   
div.style.backgroundColor = "blue";  
document.body.appendChild(div);  
divStyles[i] = div.style;  
}  
playSound();  
}  
/**  
* Plays a sound, and calls setInterval() to call the setMeter() function  
* periodically, to display the sound spectrum data.  
*/  
function playSound()   
{  
if (snd.url != null)  
{  
snd.close();  
}  
snd.load(req);  
var channel = snd.play();  
timer = setInterval(setMeter, 100);  
snd.addEventListener(air.Event.SOUND_COMPLETE, onPlaybackComplete);  
}  
/**  
* Computes the width of each of the 256 colored DIV tags in the document,  
* based on data returned by the call to SoundMixer.computeSpectrum(). The   
* first 256 floating point numbers in the byte array represent the data from  
* the left channel, and then next 256 floating point numbers represent the   
* data from the right channel.  
*/  
function setMeter()  
{  
air.SoundMixer.computeSpectrum(bytes, false, 0);  
C# Create PDF Library SDK to convert PDF from other file formats
file. Create and save editable PDF with a blank page, bookmarks, links, signatures, etc. Create fillable PDF document with fields.
excel pdf bookmarks; create bookmarks pdf files
VB.NET Create PDF Library SDK to convert PDF from other file
Create and save editable PDF with a blank page, bookmarks, links, signatures, etc. Create fillable PDF document with fields in Visual Basic .NET application.
pdf export bookmarks; create pdf bookmarks
289
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
var n;
for (var i = 0; i < CHANNEL_LENGTH; i++)   
{  
bytes.position = i * 4;  
n = Math.abs(bytes.readFloat());  
bytes.position = 256*4 + i * 4;  
n += Math.abs(bytes.readFloat());  
divStyles[i].width = n * PLOT_WIDTH;  
}  
}  
/**  
* When the sound is done playing, remove the intermediate process   
* started by setInterval().  
*/  
function onPlaybackComplete(event)  
{  
clearInterval(interval);  
}  
</script>  
<body onload="init()">  
</body>  
</html>
This example first loads and plays a sound file and then uses the 
setInterval()
function to monitor the 
SoundMixer.computeSpectrum()
method, which stores the sound wave data in the 
bytes
ByteArray object.
The sound waveform is plotted by setting the width of 
div
elements representing a bar graph.
Capturing sound input
The Microphone class lets your application connect to a microphone or other sound input device on the user’s system. 
An application can broadcast the input audio to that system’s speakers or send the audio data to a remote server, such 
as the Flash Media Server. You cannot access raw audio data from the microphone; you can only send audio to the 
system’s speakers or send compressed audio data to a remote server. You can use either Speex or Nellymoser codec for 
data sent to a remote server. (The Speex codec is available in AIR 1.5.)
Accessing a microphone
The Microphone class does not have a constructor method. Instead, you use the static 
Microphone.getMicrophone()
method to obtain a new Microphone instance, as the following example shows:
var mic = air.Microphone.getMicrophone();  
Calling the 
Microphone.getMicrophone()
method without a parameter returns the first sound input device 
discovered on the user’s system. 
A system can have more than one sound input device attached to it. Your application can use the 
Microphone.names
property to get an array of the names of all available sound input devices. Then it can call the 
Microphone.getMicrophone()
method with an 
index
parameter that matches the index value of a device’s name in 
the array.
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. PDF Create.
pdf bookmark editor; adding bookmarks to a pdf
XDoc.Word for .NET, Advanced .NET Word Processing Features
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. Word Create. Create Word from PDF; Create Word
how to add bookmarks to a pdf; bookmark pdf reader
290
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
A system might not have a microphone or other sound input device attached to it. You can use the 
Microphone.names
property or the 
Microphone.getMicrophone()
method to check whether the user has a sound input device installed. 
If the user doesn’t have a sound input device installed, the 
names
array has a length of zero, and the 
getMicrophone()
method returns a value of 
null
Routing microphone audio to local speakers
Audio input from a microphone can be routed to the local system speakers by calling the 
Microphone.setLoopback()
method with a parameter value of 
true
When sound from a local microphone is routed to local speakers, there is a risk of creating an audio feedback loop. 
This can cause loud squealing sounds and can potentially damage sound hardware. Calling the 
Microphone.setUseEchoSuppression()
method with a parameter value of 
true
reduces, but does not completely 
eliminate, the risk that audio feedback will occur. Adobe recommends that you always call 
Microphone.setUseEchoSuppression(true)
before calling 
Microphone.setLoopback(true)
, unless you are 
certain that the user is playing back the sound using headphones or something other than speakers.
The following code shows how to route the audio from a local microphone to the local system speakers:
var mic = air.Microphone.getMicrophone();  
mic.setUseEchoSuppression(true);  
mic.setLoopBack(true);
Altering microphone audio
Your application can alter the audio data that comes from a microphone in two ways. First, it can change the gain of 
the input sound, which effectively multiplies the input values by a specified amount. This creates a louder or quieter 
sound. The 
Microphone.gain
property accepts numeric values from 0 through 100. A value of 50 acts like a multiplier 
of one and specifies normal volume. A value of zero acts like a multiplier of zero and effectively silences the input 
audio. Values above 50 specify higher than normal volume.
Your application can also change the sample rate of the input audio. Higher sample rates increase sound quality, but 
they also create denser data streams that use more resources for transmission and storage. The 
Microphone.rate
property represents the audio sample rate measured in kilohertz (kHz). The default sample rate is 8 kHz. You can set 
the 
Microphone.rate
property to a value higher than 8 kHz if your microphone supports the higher rate. For 
example, setting the 
Microphone.rate
property to 11 sets the sample rate to 11 kHz; setting it to 22 sets the sample 
rate to 22 kHz, and so on. The sample rates available depend on the selected codec. When you use the Nellymoser 
codec, you can specify 5, 8, 11, 16, 22 and 44 kHz as the sample rate. When you use Speex codec (available in AIR 1.5), 
you can only use 16 kHz.
Detecting microphone activity
To conserve bandwidth and processing resources, the runtime tries to detect when a microphone transmits no sound. 
When the microphone’s activity level stays below the silence level threshold for a period of time, the runtime stops 
transmitting the audio input and dispatches an 
activity
event. If you use the Speex codec (available in AIR 1.5), set 
the silence level to 0, to ensure that the application continuously transmits audio data. Speex voice activity detection 
automatically reduces bandwidth.
Three properties of the Microphone class monitor and control the detection of activity:
• The read-only 
activityLevel
property indicates the amount of sound the microphone is detecting, on a scale 
from 0 to 100.
291
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
• The 
silenceLevel
property specifies the amount of sound needed to activate the microphone and dispatch an 
activity
event. The 
silenceLevel
property also uses a scale from 0 to 100, and the default value is 10.
• The 
silenceTimeout
property describes the number of milliseconds that the activity level must stay below the 
silence level before an 
activity
event is dispatched. The default 
silenceTimeout
value is 2000.
Both the 
Microphone.silenceLevel
property and the 
Microphone.silenceTimeout
property are read only, but 
their values can be changed by using the 
Microphone.setSilenceLevel()
method.
In some cases, the process of activating the microphone when new activity is detected can cause a short delay. Keeping 
the microphone active at all times can remove such activation delays. Your application can call the 
Microphone.setSilenceLevel()
method with the 
silenceLevel
parameter set to zero. This keeps the microphone 
active and gathering audio data, even when no sound is detected. Conversely, setting the 
silenceLevel
parameter to 
100 prevents the microphone from being activated at all.
The following example displays information about the microphone and reports on 
activity
events and 
status
events dispatched by a Microphone object:
var deviceArray = air.Microphone.names;  
air.trace("Available sound input devices:");  
for (i = 0; i < deviceArray.length; i++)  
{  
air.trace("   " + deviceArray[i]);  
}  
var mic = air.Microphone.getMicrophone();  
mic.gain = 60;  
mic.rate = 11;  
mic.setUseEchoSuppression(true);  
mic.setLoopBack(true);  
mic.setSilenceLevel(5, 1000);  
mic.addEventListener(air.ActivityEvent.ACTIVITY, this.onMicActivity);  
var micDetails = "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';  
air.trace(micDetails);  
function onMicActivity(event)  
{  
air.trace("activating=" + event.activating + ", activityLevel=" +   
mic.activityLevel);  
}
When you run the preceding example, speak or make noises into your system microphone and watch the resulting 
trace statements appear in the console.
Sending audio to and from a media server
Additional audio capabilities are available when using a streaming media server such as Flash Media Server.
292
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
In particular, your application can attach a Microphone object to a runtime.flash.net.NetStream object and transmit 
data directly from the user’s microphone to the server. Audio data can also be streamed from the server to an AIR 
application.
AIR 1.5 introduces support for the Speex codec. To set the codec used for compressed audio sent to the media server, 
set the 
codec
property of the Microphone object. This property can have two values, which are enumerated in the 
SoundCodec class. Setting the codec property to 
SoundCodec.SPEEX
selects the Speex codec for compressing audio. 
Setting the property to 
SoundCodec.NELLYMOSER
(the default) selects the Nellymoser codec for compressing audio. 
For more information, see the Flash Media Server documentation online at 
http://www.adobe.com/support/documentation.
293
Last updated 9/28/2011
Chapter 19: Client system environment
Flash Player 9 and later, Adobe AIR 1.0 and later
This discussion explains how to interact with the user’s system. It shows you how to determine what features are 
supported and how to build multilingual applications using the user’s installed input method editor (IME) if available. 
It also shows typical uses for application domains. 
More Help topics 
flash.system.System
flash.system.Capabilities
Basics of the client system environment
Flash Player 9 and later, Adobe AIR 1.0 and later
As you build more advanced applications, you may find a need to know details about—and access functions of—your 
users’ operating systems. The flash.system package contains a collection of classes that allow you to access system-level 
functionality such as the following:
• Determining which application and security domain code is executing in
• Determining the capabilities of the user’s Flash runtime (such as Flash® Player or Adobe® AIR™) instance, such as 
the screen size (resolution) and whether certain functionality is available, such as mp3 audio
• Building multilingual sites using the IME
• Interacting with the Flash runtime’s container (which could be an HTML page or a container application).
• Saving information to the user’s clipboard
The flash.system package also includes the IMEConversionMode and SecurityPanel classes. These classes contain 
static constants that you use with the IME and Security classes, respectively.
Important concepts and terms
The following reference list contains important terms:
Operating system 
The main program that runs on a computer, within which all other applications run—such as 
Microsoft Windows, Mac OS X, or Linux®.
Clipboard 
The operating system’s container for holding text or items that are copied or cut, and from which items are 
pasted into applications.
Application domain 
A mechanism for separating classes used in different SWF files, so that if the SWF files include 
different classes with the same name, the classes don’t overwrite each other.
IME (input method editor) 
A program (or operating system tool) that is used to enter complex characters or symbols 
using a standard keyboard.
294
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Client system environment
Last updated 9/28/2011
Client system 
In programming terms, a client is the part of an application (or whole application) that runs on an 
individual’s computer and is used by a single user. The client system is the underlying operating system on the user’s 
computer.
Using the System class
Flash Player 9 and later, Adobe AIR 1.0 and later
The System class contains methods and properties that allow you to interact with the user’s operating system and 
retrieve the current memory usage of the runtime. The methods and properties of the System class also allow you to 
listen for 
imeComposition
events, instruct the runtime to load external text files using the user’s current code page or 
to load them as Unicode, or set the contents of the user’s clipboard.
Getting data about the user’s system at run time
Flash Player 9 and later, Adobe AIR 1.0 and later
By checking the 
System.totalMemory
property, you can determine the amount of memory (in bytes) that the 
runtime is currently using. This property allows you to monitor memory usage and optimize your applications based 
on how the memory level changes. For example, if a particular visual effect causes a large increase in memory usage, 
you may want to consider modifying the effect or eliminating it altogether.
The 
System.ime
property is a reference to the currently installed Input Method Editor (IME). This property allows 
you to listen for 
imeComposition
events (
flash.events.IMEEvent.IME_COMPOSITION
) by using the 
addEventListener()
method.
The third property in the System class is 
useCodePage
. When 
useCodePage
is set to 
true
, the runtime uses the 
traditional code page of the operating system to load external text files. If you set this property to 
false
, you tell the 
runtime to interpret the external file as Unicode.
If you set 
System.useCodePage
to 
true
, remember that the traditional code page of the operating system must 
include the characters used in your external text file in order for the text to display. For example, if you load an external 
text file that contains Chinese characters, those characters cannot display on a system that uses the English Windows 
code page because that code page does not include Chinese characters.
To ensure that users on all platforms can view the external text files that are used in your application, you should 
encode all external text files as Unicode and leave 
System.useCodePage
set to 
false
by default. This way, the runtime 
interprets the text as Unicode.
Using the Capabilities class
Flash Player 9 and later, Adobe AIR 1.0 and later
The Capabilities class allows developers to determine the environment in which an application is being run. Using 
various properties of the Capabilities class, you can find out the resolution of the user’s system, whether the user’s 
system supports accessibility software, and the language of the user’s operating system, as well as the currently installed 
version of the Flash runtime. 
Documents you may be interested
Documents you may be interested