c# pdf diff : Add bookmarks to pdf online Library SDK class asp.net .net web page ajax air_htmldevguide28-part473

275
Last updated 9/28/2011
Chapter 18: Working with sound
The Adobe® AIR® classes include many capabilities not available to HTML content running in the browser, including 
capabilities for loading and playing sound content. 
More Help topics 
flash.media.Sound
flash.media.Microphone
flash.events.SampleDataEvent
Basics of working with sound
Before you can control a sound, you need to load the sound into the Adobe AIR application. There are five ways you 
can get audio data into AIR:
• You can load an external sound file such as an mp3 file into the application.
• You can embed the sound information into a SWF file, load it (using 
<script src="[swfFile].swf" 
type="application/x-shockwave-flash"/
>) and play it.
• You can get audio input using a microphone attached to a user’s computer.
• You can access sound data that’s streamed from a server. 
• You can dynamically generate sound data. 
When you load sound data from an external sound file, you can begin playing back the start of the sound file while the 
rest of the sound data is still loading. 
Although there are various sound file formats used to encode digital audio, AIR supports sound files that are stored in 
the mp3 format. It cannot directly load or play sound files in other formats like WAV or AIFF.
While you’re working with sound in AIR, you’ll likely work with several classes from the runtime.flash.media package. 
The Sound class is the class you use to get access to audio information by loading a sound file or assigning a function 
to an event that samples sound data and then starting playback. Once you start playing a sound, AIR gives you access 
to a SoundChannel object. An audio file that you’ve loaded can only be one of several sounds that an application plays 
simultaneously. Each individual sound that’s playing uses its own SoundChannel object; the combined output of all 
the SoundChannel objects mixed together is what actually plays over the speakers. You use this SoundChannel 
instance to control properties of the sound and to stop its playback. Finally, if you want to control the combined audio, 
the SoundMixer class gives you control over the mixed output. 
You can also use several other runtime classes to perform more specific tasks when you’re working with sound in AIR. 
For more information on all the sound-related classes, see “Understanding the sound architecture” on page  276.
The Adobe AIR developer’s center provides a sample application: Using Sound in an HTML-based Application 
(http://www.adobe.com/go/learn_air_qs_sound_html_en).
Add bookmarks to pdf online - 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
bookmarks in pdf from word; adding bookmarks to pdf reader
Add bookmarks to pdf online - 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
pdf bookmark; adding bookmarks to a pdf
276
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Understanding the sound architecture
Your applications can load sound data from five main sources: 
• External sound files loaded at run time
• Sound resources embedded within a SWF file
• Sound data from a microphone attached to the user’s system
• Sound data streamed from a remote media server, such as Flash Media Server
• Sound data being generated dynamically by using the 
sampleData
event handler
Sound data can be fully loaded before it is played back, or it can be streamed, meaning that it is played back while it is 
still loading. 
Adobe AIR supports sound files that are stored in the mp3 format. They cannot directly load or play sound files in 
other formats like WAV or AIFF. (However, AIR can also load and play AAC audio files using the NetStream class.)
The AIR sound architecture includes the following classes:
Each sound that is loaded and played needs its own instance of the Sound class and the SoundChannel class. During 
playback, the SoundMixer class mixes the output from multiple SoundChannel instances.
The Sound, SoundChannel, and SoundMixer classes are not used for sound data obtained from a microphone or from 
a streaming media server like Flash Media Server.
Loading external sound files
Each instance of the Sound class exists to load and trigger the playback of a specific sound resource. An application 
can’t reuse a Sound object to load more than one sound. To load a new sound resource, the application needs to create 
another Sound object.
Class
Description
Sound
The Sound class handles the loading of sound, manages basic sound properties, and starts a sound playing.
SoundChannel
When an application plays a Sound object, a new SoundChannel object is created to control the playback. The 
SoundChannel object controls the volume of both the left and right playback channels of the sound. Each 
sound that plays has its own SoundChannel object.
SoundLoaderContext
The SoundLoaderContext class specifies how many seconds of buffering to use when loading a sound, and 
whether the runtime looks for a cross-domain policy file from the server when loading a file. A 
SoundLoaderContext object is used as a parameter to the Sound.load() method.
SoundMixer
The SoundMixer class controls playback and security properties that pertain to all sounds in an application. In 
effect, multiple sound channels are mixed through a common SoundMixer object. Property values in the 
SoundMixer object affect all SoundChannel objects that are currently playing.
SoundTransform
The SoundTransform class contains values that control sound volume and panning. A SoundTransform object 
can be applied to an individual SoundChannel object, to the global SoundMixer object, or to a Microphone 
object, among others.
ID3Info
An ID3Info object contains properties that represent ID3 metadata information that is often stored in MP3 
sound files. 
Microphone
The Microphone class represents a microphone or other sound input device attached to the user’s computer. 
Audio input from a microphone can be routed to local speakers or sent to a remote server. The Microphone 
object controls the gain, sampling rate, and other characteristics of its own sound stream.
VB.NET PDF File Split Library: Split, seperate PDF into multiple
This online VB tutorial aims to illustrate the process of PDF document Add necessary references split a PDF file into multiple ones by PDF bookmarks or outlines
create pdf bookmarks; create bookmark pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Free download library and use online C# class source codes in .NET Add necessary references: to split a PDF file into multiple ones by PDF bookmarks or outlines
bookmark pdf acrobat; export pdf bookmarks to text file
277
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Creating a sound object
If you are loading a small sound file, such as a click sound to be attached to a button, your application can create a 
Sound and have it automatically load the sound file, as the following example shows:
var req = new air.URLRequest("click.mp3");  
var s = new air.Sound(req);
The 
Sound()
constructor accepts a URLRequest object as its first parameter. When a value for the URLRequest 
parameter is supplied, the new Sound object starts loading the specified sound resource automatically.
In all but the simplest cases, your application should pay attention to the sound’s loading progress and watch for errors 
during loading. For example, if the click sound is fairly large, the application may not completely load it by the time 
the user clicks the button that triggers the sound. Trying to play an unloaded sound could cause a run-time error. It’s 
safer to wait for the sound to load completely before letting users take actions that can start sounds playing.
About sound events
A Sound object dispatches a number of different events during the sound loading process. Your application can listen 
for these events to track loading progress and make sure that the sound loads completely before playing. The following 
table lists the events that the Sound object is able to dispatch: 
The following code illustrates how to play a sound after it has finished loading: 
var s = new air.Sound();  
s.addEventListener(air.Event.COMPLETE, onSoundLoaded);  
var req = new air.URLRequest("bigSound.mp3");  
s.load(req);  
function onSoundLoaded(event)  
{  
var localSound = event.target;  
localSound.play();  
}
First, the code sample creates a new Sound object without giving it an initial value for the URLRequest parameter. Then, 
it listens for the 
complete
event from the Sound object, which causes the 
onSoundLoaded()
method to execute when 
all the sound data is loaded. Next, it calls the 
Sound.load()
method with a new URLRequest value for the sound file.
Event
Description
open
(air.Event.OPEN)
Dispatched right before the sound loading operation begins.
progress
(air.ProgressEvent.PROGRESS)
Dispatched periodically during the sound loading process when data is received from the file or stream.
id3
(air.Event.ID3)
Dispatched when ID3 data is available for an mp3 sound.
complete
(air.Event.COMPLETE)
Dispatched when all of the sound resource’s data has been loaded.
ioError
(air.IOErrorEvent.IO_ERROR)
Dispatched when a sound file cannot be located or when the loading process is interrupted before all 
sound data can be received.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
edit pdf bookmarks; create pdf bookmarks online
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. Comments, forms and multimedia. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references: RasterEdge.Imaging.Basic.dll.
add bookmarks to pdf reader; add bookmarks to pdf file
278
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
The 
onSoundLoaded()
method executes when the sound loading is complete. The 
target
property of the Event 
object is a reference to the Sound object. Calling the 
play()
method of the Sound object then starts the sound 
playback.
Monitoring the sound loading process
Sound files can be large and take a long time to load, especially if they are loaded from the Internet. An application can 
play sounds before they are fully loaded. You might want to give the user an indication of how much of the sound data 
has been loaded and how much of the sound has already been played.
The Sound class dispatches two events that make it relatively easy to display the loading progress of a sound: 
progress
and 
complete
. The following example shows how to use these events to display progress information about the sound 
being loaded:
var s = new Sound();  
s.addEventListener(air.ProgressEvent.PROGRESS,  
onLoadProgress);  
s.addEventListener(air.Event.COMPLETE,   
onLoadComplete);  
s.addEventListener(air.IOErrorEvent.IO_ERROR,   
onIOError);  
var req = new air.URLRequest("bigSound.mp3");  
s.load(req);  
function onLoadProgress(event)  
{  
var loadedPct = Math.round(100 * (event.bytesLoaded / event.bytesTotal));  
air.trace("The sound is " + loadedPct + "% loaded.");  
}  
function onLoadComplete(event)  
{  
var localSound = event.target;  
localSound.play();  
}  
function onIOError(event)  
{  
air.trace("The sound could not be loaded: " + event.text);  
}
This code first creates a Sound object and then adds listeners to that object for the 
progress
and 
complete
events. 
After the 
Sound.load()
method has been called and the first data is received from the sound file, a 
progress
event 
occurs, and triggers the 
onSoundLoadProgress()
method.
The fraction of the sound data that has been loaded is equal to the value of the 
bytesLoaded
property of the 
ProgressEvent object divided by the value of the 
bytesTotal
property. The same 
bytesLoaded
and 
bytesTotal
properties are available on the Sound object as well.
This example also shows how an application can recognize and respond to an error when loading sound files. For 
example, if a sound file with the given filename cannot be located, the Sound object dispatches an 
ioError
event. In 
the previous code, the 
onIOError()
method executes and displays a brief error message when an error occurs.
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; PDF Text Write & Extract. Insert and add text to any page of PDF document with
convert word pdf bookmarks; how to add bookmarks on pdf
XDoc.Word for .NET, Advanced .NET Word Processing Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Word to PDF; Convert Word to HTML5; Convert Add and insert a blank page or multiple
create pdf bookmark; how to bookmark a pdf file
279
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Working with embedded sounds
In AIR, you can use JavaScript to access sounds embedded in SWF files. You can load these SWF files into the 
application using any of the following means:
• By loading the SWF file with a 
<script>
tag in the HTML page
• By loading a SWF file using the runtime.flash.display.Loader class
The exact method of embedding a sound file into your application’s SWF file varies according to your SWF content 
development environment. For information on embedding media in SWF files, see the documentation for your 
SWF content development environment
To use the embedded sound, you reference the class name for that sound in ActionScript. For example, the 
following code starts by creating an instance of the automatically generated DrumSound class:
var drum = new DrumSound();  
var channel = drum.play();
DrumSound is a subclass of the flash.media.Sound class, so it inherits the methods and properties of the Sound 
class. The 
play()
method included, as the preceding example shows.
Working with streaming sound files
When a sound file or video file is playing back while its data is still being loaded, it is said to be streaming. Sound files 
loaded from a remote server are often streamed so that the user doesn’t have to wait for all the sound data to load before 
listening to the sound.
The 
SoundMixer.bufferTime
property represents the number of milliseconds of sound data that an application 
gathers before letting the sound play. In other words, if the 
bufferTime
property is set to 5000, the application loads 
at least 5000 milliseconds worth of data from the sound file before the sound begins to play. The default 
SoundMixer.bufferTime
value is 1000.
Your application can override the global 
SoundMixer.bufferTime
value for an individual sound by explicitly 
specifying a new 
bufferTime
value when loading the sound. To override the default buffer time, first create an 
instance of the SoundLoaderContext class, set its 
bufferTime
property, and then pass it as a parameter to the 
Sound.load()
method. The following example shows this:
var s = new air.Sound();  
var url = "http://www.example.com/sounds/bigSound.mp3";  
var req = new air.URLRequest(url);  
var context = new air.SoundLoaderContext(8000, true);  
s.load(req, context);  
s.play();
As playback continues, AIR tries to keep the sound buffer at the same size or greater. If the sound data loads faster than 
the playback speed, playback continues without interruption. However, if the data loading rate slows down because of 
network limitations, the playhead could reach the end of the sound buffer. If this happens, playback is suspended, 
though it automatically resumes once more sound data has been loaded.
To find out if playback is suspended because AIR is waiting for data to load, use the 
Sound.isBuffering
property.
XDoc.PowerPoint for .NET, All Mature Features Introductions
navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert PowerPoint to PDF; Convert PowerPoint to HTML5; Add a blank page or multiple pages to
how to add bookmark in pdf; export excel to pdf with bookmarks
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Excel to PDF; Convert Excel to HTML5; Convert Add a blank page or multiple pages to
bookmark page in pdf; how to bookmark a pdf in reader
280
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Working with dynamically generated audio
Instead of loading or streaming an existing sound, you can generate audio data dynamically. You can generate audio 
data when you assign an event listener for the 
sampleData
event of a Sound object. (The 
sampleData
event is defined 
in the SampleDataEvent class.) In this environment, the Sound object doesn’t load sound data from a file. Instead, it 
acts as a socket for sound data that is being streamed to it by using the function you assign to this event. 
When you add a 
sampleData
event listener to a Sound object, the object periodically requests data to add to the sound 
buffer. This buffer contains data for the Sound object to play. When you call the 
play()
method of the Sound object, 
it dispatches the 
sampleData
event when requesting new sound data. (This is true only when the Sound object has not 
loaded mp3 data from a file.)
The SampleDataEvent object includes a 
data
property. In your event listener, you write ByteArray objects to this 
data
object. The byte arrays you write to this object add to buffered sound data that the Sound object plays. The byte array 
in the buffer is a stream of floating-point values from -1 to 1. Each floating-point value represents the amplitude of one 
channel (left or right) of a sound sample. Sound is sampled at 44,100 samples per second. Each sample contains a left 
and right channel, interleaved as floating-point data in the byte array. 
In your handler function, you use the 
ByteArray.writeFloat()
method to write to the 
data
property of the 
sampleData
event. For example, the following code generates a sine wave:
var mySound = new air.Sound();  
mySound.addEventListener(air.SampleDataEvent.SAMPLE_DATA, sineWaveGenerator);  
mySound.play();  
function sineWaveGenerator(event)  
{  
for (i = 0; i < 8192; i++)  
 
var n = Math.sin((i + event.position) / Math.PI / 4);  
event.data.writeFloat(n);  
event.data.writeFloat(n);  
 
}
When you call 
Sound.play()
, the application starts calling your event handler, requesting sound sample data. The 
application continues to send events as the sound plays back until you stop providing data, or until you call 
SoundChannel.stop()
.
The latency of the event varies from platform to platform, and could change in future versions of AIR. Do not depend 
on a specific latency; calculate it instead. To calculate the latency, use the following formula:
(SampleDataEvent.position / 44.1) - SoundChannelObject.position
Provide from 2048 through 8192 samples to the 
data
property of the SampleDataEvent object (for each call to the 
event listener). For best performance, provide as many samples as possible (up to 8192). The fewer samples you 
provide, the more likely it is that clicks and pops occur during playback. This behavior can differ on various platforms 
and can occur in various situations—for example, when resizing the browser. Code that works on one platform when 
you provide only 2048 sample might not work as well when run on a different platform. If you require the lowest 
latency possible, consider making the amount of data user-selectable.
If you provide fewer than 2048 samples (per call to the 
sampleData
event listener), the application stops after playing 
the remaining samples. It then dispatches a SoundComplete event.
281
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Modifying sound from mp3 data
You use the 
Sound.extract()
method to extract data from a Sound object. You can use (and modify) that data to 
write to the dynamic stream of another Sound object for playback. For example, the following code uses the bytes of a 
loaded mp3 file and passes them through a filter function, 
upOctave()
:
var mySound = new air.Sound();  
var sourceSnd = new air.Sound();  
var urlReq = new air.URLRequest("test.mp3");  
sourceSnd.load(urlReq);  
sourceSnd.addEventListener(air.Event.COMPLETE, loaded);  
function loaded(event)  
{  
mySound.addEventListener(SampleDataEvent.SAMPLE_DATA, processSound);  
mySound.play();  
}  
function processSound(event)  
{  
var bytes = new air.ByteArray();  
sourceSnd.extract(bytes, 8192);  
event.data.writeBytes(upOctave(bytes));  
}  
function upOctave(bytes)  
{  
var returnBytes = new air.ByteArray();  
bytes.position = 0;  
while(bytes.bytesAvailable > 0)  
 
returnBytes.writeFloat(bytes.readFloat());  
returnBytes.writeFloat(bytes.readFloat());  
if (bytes.bytesAvailable > 0)  
{  
bytes.position += 8;  
}  
 
return returnBytes;  
}
Limitations on generated sounds
When you use a 
sampleData
event listener with a Sound object, the only other Sound methods that are enabled are 
Sound.extract()
and 
Sound.play()
. Calling any other methods or properties results in an exception. All methods 
and properties of the SoundChannel object are still enabled.
Playing sounds
Playing a loaded sound can be as simple as calling the 
Sound.play()
method for a Sound object, as follows:
var req = new air.URLRequest("smallSound.mp3");  
var snd = new air.Sound(req);  
snd.play();
282
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Sound playback operations
When playing back sounds, you can perform the following operations:
• Play a sound from a specific starting position
• Pause a sound and resume playback from the same position later
• Know exactly when a sound finishes playing
• Track the playback progress of a sound
• Change volume or panning while a sound plays
To perform these operations during playback, use the SoundChannel, SoundMixer, and SoundTransform classes.
The SoundChannel class controls the playback of a single sound. The 
SoundChannel.position
property can be 
thought of as a playhead, indicating the current point in the sound data that’s being played. 
When an application calls the 
Sound.play()
method, a new instance of the SoundChannel class is created to control 
the playback. 
Your application can play a sound from a specific starting position by passing that position, in terms of milliseconds, 
as the 
startTime
parameter of the 
Sound.play()
method. It can also specify a fixed number of times to repeat the 
sound in rapid succession by passing a numeric value in the 
loops
parameter of the 
Sound.play()
method. 
When the 
Sound.play()
method is called with both a 
startTime
parameter and a 
loops
parameter, the sound is 
played back repeatedly from the same starting point each time. The following code shows this:
var req = new air.URLRequest("repeatingSound.mp3");  
var snd = new air.Sound();  
snd.play(1000, 3);
In this example, the sound is played from a point one second after the start of the sound, three times in succession.
Pausing and resuming a sound
If your application plays long sounds, like songs or podcasts, you probably want to let users pause and resume the 
playback of those sounds. A sound cannot literally be paused during playback; it can only be stopped. However, a 
sound can be played starting from any point. You can record the position of the sound at the time it was stopped, and 
then replay the sound starting at that position later.
For example, let’s say your code loads and plays a sound file like this:
var req = new air.URLRequest("bigSound.mp3");  
var snd = new air.Sound(req);  
var channel = snd.play();
While the sound plays, the 
position
property of the 
channel
object indicates the point in the sound file that is 
currently being played. Your application can store the position value before stopping the sound from playing, as 
follows:
var pausePosition = channel.position;  
channel.stop();
To resume playing the sound, pass the previously stored position value to restart the sound from the same point it 
stopped at before.
channel = snd.play(pausePosition);
283
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
Monitoring playback
Your application might want to know when a sound stops playing. Then it can start playing another sound or clean up 
some resources used during the previous playback. The SoundChannel class dispatches a 
soundComplete
event when 
its sound finishes playing. Your application can listen for this event and take appropriate action, as the following 
example shows:
var snd = new air.Sound("smallSound.mp3");  
var channel = snd.play();  
s.addEventListener(air.Event.SOUND_COMPLETE, onPlaybackComplete);  
public function onPlaybackComplete(event)  
{  
air.trace("The sound has finished playing.");  
}
The SoundChannel class does not dispatch 
progress
events during playback. To report on playback progress, your 
application can set up its own timing mechanism and track the position of the sound playhead.
To calculate what percentage of a sound has been played, you can divide the value of the 
SoundChannel.position
property by the length of the sound data that’s being played:
var playbackPercent = 100 * (channel.position / snd.length);
However, this code only reports accurate playback percentages if the sound data was fully loaded before playback 
began. The 
Sound.length
property shows the size of the sound data that is currently loaded, not the eventual size of 
the entire sound file. To track the playback progress of a streaming sound that is still loading, your application should 
estimate the eventual size of the full sound file and use that value in its calculations. You can estimate the eventual 
length of the sound data using the 
bytesLoaded
and 
bytesTotal
properties of the Sound object, as follows:
var estimatedLength = Math.ceil(snd.length / (snd.bytesLoaded / snd.bytesTotal));  
var playbackPercent = 100 * (channel.position / estimatedLength);
The following code loads a larger sound file and uses the 
setInterval()
function as its timing mechanism for 
showing playback progress. It periodically reports on the playback percentage, which is the current position value 
divided by the total length of the sound data:
var snd = new air.Sound();  
var url = "http://www.example.com/sounds/test.mp3";  
var req = new air.URLRequest(url);  
snd.load(req);  
var channel = snd.play();  
var timer = setInterval(monitorProgress, 100);  
snd.addEventListener(air.Event.SOUND_COMPLETE, onPlaybackComplete);  
function monitorProgress(event)  
{  
var estimatedLength = Math.ceil(snd.length / (snd.bytesLoaded / snd.bytesTotal));  
var playbackPercent = Math.round(100 * (channel.position / estimatedLength));  
air.trace("Sound playback is " + playbackPercent + "% complete.");  
}  
function onPlaybackComplete(event)  
{  
air.trace("The sound has finished playing.");  
clearInterval(timer);  
}
284
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with sound
Last updated 9/28/2011
After the sound data starts loading, this code calls the 
snd.play()
method and stores the resulting SoundChannel 
object in the 
channel
variable. Then it adds a 
monitorProgress()
method, which the 
setInterval()
function calls 
repeatedly. The code uses an event listener to the SoundChannel object for the 
soundComplete
event that occurs when 
playback is complete.
The 
monitorProgress()
method estimates the total length of the sound file based on the amount of data that has 
already been loaded. It then calculates and displays the current playback percentage.
When the entire sound has been played, the 
onPlaybackComplete()
function executes. This function removes the 
callback method for the 
setInterval()
function, so that the application doesn’t display progress updates after 
playback is done.
Stopping streaming sounds
There is a quirk in the playback process for sounds that are streaming—that is, for sounds that are still loading while 
they are being played. When you call the 
stop()
method on a SoundChannel instance that is playing back a streaming 
sound, the sound playback stops and then it restarts from the beginning of the sound. This occurs because the sound 
loading process is still underway. To stop both the loading and the playback of a streaming sound, call the 
Sound.close()
method.
Controlling sound volume and panning
An individual SoundChannel object controls both the left and the right stereo channels for a sound. If an mp3 sound 
is a monaural sound, the left and right stereo channels of the SoundChannel object contain identical waveforms.
You can find out the amplitude of each stereo channel of the sound being played using the 
leftPeak
and 
rightPeak
properties of the SoundChannel object. These properties show the peak amplitude of the sound waveform itself. They 
do not represent the actual playback volume. The actual playback volume is a function of the amplitude of the sound 
wave and the volume values set in the SoundChannel object and the SoundMixer class.
The pan property of a SoundChannel object can be used to specify a different volume level for each of the left and right 
channels during playback. The pan property can have a value ranging from -1 to 1. A value of -1 means the left channel 
plays at top volume while the right channel is silent. A value of 1 means the right channel plays at top volume while 
the left channel is silent. Values in between -1 and 1 set proportional values for the left and right channel values. A 
value of 0 means that both channels play at a balanced, mid-volume level.
The following code example creates a SoundTransform object with a volume value of 0.6 and a pan value of -1 (upper-
left channel volume and no right channel volume). It passes the SoundTransform object as a parameter to the 
play()
method. The 
play()
method applies that SoundTransform object to the new SoundChannel object that is created to 
control the playback.
var req = new air.URLRequest("bigSound.mp3");  
var snd = new air.Sound(req);   
var trans = new air.SoundTransform(0.6, -1);  
var channel = snd.play(0, 1, trans);
You can alter the volume and panning while a sound plays. Set the 
pan
or 
volume
properties of a SoundTransform 
object and then apply that object as the 
soundTransform
property of a SoundChannel object.
You can also set global volume and pan values for all sounds at once, using the 
soundTransform
property of the 
SoundMixer class. The following example shows this:
SoundMixer.soundTransform = new air.SoundTransform(1, -1);
You can also use a SoundTransform object to set volume and pan values for a Microphone object (see “Capturing 
sound input” on page 289).
Documents you may be interested
Documents you may be interested