pdf to image c# open source : How to fill pdf form in reader SDK Library API .net asp.net html sharepoint fulton_fulton45-part557

2. The number of sound objects created is a huge problem. For some browsers, such
as Chrome, the number of active sounds caps out at about 50. After that, no sounds
play at all.
Figure 7-8. Space Raiders creating sounds on the fly
Iteration #3: Creating a Sound Pool
So, now we know we don’t want to play an HTMLAudioElement object repeatedly or create
unlimited sound objects on the fly. However, what if we cap the number of audio objects
we create and put those objects in a pool so that we can use them over and over? This
will save us memory, and after the sounds are loaded, we shouldn’t see any loading pause
before they are played, right?
We will implement a solution that uses HTMLAudioElement objects as general-purpose
sound objects. We will keep a pool of them and change the src attribute to whatever
sound we want to play. This appears to be an elegant solution that reuses as much as
possible, in addition to giving us a lot of flexibility as to which sounds we want to play.
In canvasApp(), we will create a new variable named MAX_SOUNDS. This will represent
the maximum number of sound objects we can create at any one time. We will also
rename our sounds array to soundPool to better describe its purpose:
Case Study in Audio: Space Raiders Game  |  429
How to fill pdf form in reader - extract form data from PDF in C#.net, ASP.NET, MVC, Ajax, WPF
Help to Read and Extract Field Data from PDF with a Convenient C# Solution
saving pdf forms in acrobat reader; using pdf forms to collect data
How to fill pdf form in reader - VB.NET PDF Form Data Read library: extract form data from PDF in vb.net, ASP.NET, MVC, Ajax, WPF
Convenient VB.NET Solution to Read and Extract Field Data from PDF
pdf data extraction to excel; export pdf form data to excel
var MAX_SOUNDS = 8;
var soundPool = new Array();
The big change here is the playSound() function. It uses the same parameters as the
one from iteration #2, but the functionality is very different:
function playSound(sound,volume) {
The first half of the function loops through the soundPool array to see whether any of
the HTMLAudioElement objects in the pool are available to play a sound. We determine
this by checking the ended property. Because only HTMLAudioElement objects that have
previously been used to play a sound are put into the pool, the ended property will be
set to true when the sound has finished playing. By replaying sounds that have finished,
we remove the issue of trying to reuse an HTMLAudioElement object to play a sound
while it is already in use:
var soundFound = false;
var soundIndex = 0;
var tempSound;
if (soundPool.length> 0) {
while (!soundFound && soundIndex < soundPool.length) {
var tSound = soundPool[soundIndex];
if (tSound.ended) {
soundFound = true;
else {
soundIndex++;
}
}
}
if (soundFound) {
tempSound = soundPool[soundIndex];
tempSound.setAttribute("src"sound + "." + audioType);
tempSound.loop = false;
tempSound.volume = volume;
tempSound.play();
If we don’t find a sound, and if the size of the pool is less than MAX_SOUNDS, we go ahead
and create a new HTMLAudioElement object, call its play() function, and push it into
the sound pool. This keeps the pool from getting too large while making sure there are
not too many HTMLAudioElement objects in the browser at any one time:
else if (soundPool.length < MAX_SOUNDS){
tempSound = document.createElement("audio");
tempSound.setAttribute("src"sound + "." + audioType);
tempSound.volume = volume;
tempSound.play();
soundPool.push(tempSound);
}
}
430  |  Chapter 7: Working with Audio
VB.NET PDF Form Data fill-in library: auto fill-in PDF form data
to PDF. Image: Remove Image from PDF Page. Image Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Extract Field Data. Data: Auto Fill-in Field
extract data from pdf to excel online; extract data out of pdf file
C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#
A professional PDF form filler control able to be integrated in Visual Studio .NET WinForm and fill in PDF form use C# language.
pdf data extraction open source; extracting data from pdf files
You can go ahead and try this iteration by loading CH7EX8.html in your HTML5-
compliant web browser. In this case, it works! You hear every sound, and the browser
doesn’t die like it would with iteration #2.
Unfortunately, there are some issues. On some browsers, there is still a pause before a
sound plays, just like with iteration #2. Again, this happens more often when the page
is loaded from an external website than when it is loaded locally in a web browser.
The worst manifestation of this comes in Google Chrome, where the sounds pause every
time they are played. Also, in Firefox, the src doesn’t change for all the objects, making
the shoot sound play when the explode sound should play, and vice versa.
Uh-oh, it looks like we need another iteration. Figure 7-9 shows Space Raiders playing
with a pool size governed by MAX_SOUNDS.
Figure 7-9. Space Raiders with a sound pool
Iteration #4: Reusing Preloaded Sounds
Even though the code in iteration #3 was pretty clean, it simply did not work for us.
Instead, we need to compromise and implement a solution that is less elegant but that
works to play sounds nearly every time they are needed. This solution must also work
both locally and when loaded from a website.
Case Study in Audio: Space Raiders Game  |  431
C# WPF PDF Viewer SDK to annotate PDF document in C#.NET
Text box. Click to add a text box to specific location on PDF page. Line color and fill can be set in properties. Copyright © <2000-2016> by <RasterEdge.com>.
make pdf form editable in reader; how to save filled out pdf form in reader
VB.NET PDF Password Library: add, remove, edit PDF file password
passwordSetting.IsAnnot = True ' Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = True ' Add password to PDF file.
pdf form field recognition; how to save a pdf form in reader
For this final iteration, we are going to use a sound pool just like in iteration #3, but it
will operate in a different way. We will not reuse sound objects for different sound files.
Instead, we will load all our sounds up front and simply play a sound object that is
currently not being used. In effect, we will “prime the pump,” creating three sound
objects for each of our two sounds, for a total of six sound objects when we start the
application. While this might not seem like the perfect solution, it appears to work fairly
well in all browsers and plays sounds in the most effective way.
In canvasApp(), we set our MAX_SOUNDS variables to 6. We could make it higher, but for
this example, we will limit it to the number of sounds we will create and preload:
var MAX_SOUNDS = 6;
We then create six variables to hold our HTMLAudioElement objects—three for the ex‐
plode sound:
var explodeSound ;
var explodeSound2 ;
var explodeSound3 ;
And three for the shoot sound:
var shootSound;
var shootSound2;
var shootSound3;
In the initApp() function, we preload all of these sound objects. Yes, we load the same
object multiple times:
explodeSound = document.createElement("audio");
document.body.appendChild(explodeSound);
audioType = supportedAudioFormat(explodeSound);
explodeSound.addEventListener("canplaythrough",itemLoaded,false);
explodeSound.setAttribute("src""explode1." + audioType);
explodeSound2 = document.createElement("audio");
document.body.appendChild(explodeSound2);
explodeSound2.addEventListener("canplaythrough",itemLoaded,false);
explodeSound2.setAttribute("src""explode1." + audioType);
explodeSound3 = document.createElement("audio");
document.body.appendChild(explodeSound3);
explodeSound3.addEventListener("canplaythrough",itemLoaded,false);
explodeSound3.setAttribute("src""explode1." + audioType);
shootSound = document.createElement("audio");
document.body.appendChild(shootSound);
shootSound.addEventListener("canplaythrough",itemLoaded,false);
shootSound.setAttribute("src""shoot1." + audioType);
shootSound2 = document.createElement("audio");
document.body.appendChild(shootSound2);
432  |  Chapter 7: Working with Audio
C# PDF Password Library: add, remove, edit PDF file password in C#
passwordSetting.IsAnnot = true; // Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = true; // Add password to PDF file.
sign pdf form reader; online form pdf output
VB.NET PDF - Annotate PDF with WPF PDF Viewer for VB.NET
Text box. Click to add a text box to specific location on PDF page. Line color and fill can be set in properties. Copyright © <2000-2016> by <RasterEdge.com>.
filling out pdf forms with reader; save data in pdf form reader
shootSound2.addEventListener("canplaythrough",itemLoaded,false);
shootSound2.setAttribute("src""shoot1." + audioType);
shootSound3 = document.createElement("audio");
document.body.appendChild(shootSound3);
shootSound3.addEventListener("canplaythrough",itemLoaded,false);
shootSound3.setAttribute("src""shoot1." + audioType);
In the itemLoaded() function, we remove the event listeners for all six loaded sounds:
shootSound.removeEventListener("canplaythrough",itemLoadedfalse);
shootSound2.removeEventListener("canplaythrough",itemLoadedfalse);
shootSound3.removeEventListener("canplaythrough",itemLoadedfalse);
explodeSound.removeEventListener("canplaythrough",itemLoaded,false);
explodeSound2.removeEventListener("canplaythrough",itemLoaded,false);
explodeSound3.removeEventListener("canplaythrough",itemLoaded,false);
Then we push each sound into our soundPool array. However, this time, we push them
as dynamic objects so that we can set the following properties, which don’t exist in the
HTMLAudioElement object:
name
The name of the sound file to play (again, without the extension).
element
The reference to the HTMLAudioElement object.
played
A Boolean that tells us whether this sound has played once or not. We need this
property because we are putting all of these sound objects into our array, but they
have not been played yet. That means their ended property has not yet been set to
true. The played property tells us whether the sound is ready to play—that is, it
has not been played yet. We will set this to true after we play the sound once:
soundPool.push({name:"explode1"element:explodeSoundplayed:false});
soundPool.push({name:"explode1"element:explodeSound2played:false});
soundPool.push({name:"explode1"element:explodeSound3played:false});
soundPool.push({name:"shoot1"element:shootSoundplayed:false});
soundPool.push({name:"shoot1"element:shootSound2played:false});
soundPool.push({name:"shoot1"element:shootSound3played:false});
Now we need to make a change in our resetApp() function. This change is to support
sounds playing in Chrome, which appears to be the only browser that has a slight issue
with loading sounds in this manner. The first time you play a sound in Chrome, there
is a pause before it starts. To alleviate this, we play each sound type once but set the
volume to 0. This will make sure a sound is loaded and ready to play the first time we
call playSound() in Chrome:
function resetApp() {
playSound(SOUND_EXPLODE,0);
Case Study in Audio: Space Raiders Game  |  433
VB.NET PDF - Annotate PDF Online with VB.NET HTML5 PDF Viewer
on PDF page. Outline width, outline color, fill color and transparency are all can be altered in properties. Drawing Tab. Item. Name. Description. 7. Draw free
how to extract data from pdf file using java; how to save a filled out pdf form in reader
C# HTML5 PDF Viewer SDK to annotate PDF document online in C#.NET
on PDF page. Outline width, outline color, fill color and transparency are all can be altered in properties. Drawing Tab. Item. Name. Description. 7. Draw free
exporting data from excel to pdf form; extract data from pdf c#
playSound(SOUND_SHOOT,0);
startLevel();
appState = STATE_PLAYING;
}
The playSound() function operates in a similar way to iteration #3. It loops through
the soundPool array looking for a sound that it can play. However, in this version, we
check  to  see  whether  the HTMLAudioElement  object  has  ended  (tSound.ele
ment.ended) or whether it has not been played (!tSound.played) yet. We also check
whether the value in the sound parameter matches the name property of the sound object
in soundPool (tSound.name == sound):
function playSound(sound,volume) {
var soundFound = false;
var soundIndex = 0;
var tempSound;
if (soundPool.length > 0) {
while (!soundFound && soundIndex < soundPool.length) {
var tSound = soundPool[soundIndex];
if ((tSound.element.ended || !tSound.played&& 
tSound.name == sound) {
soundFound = true;
tSound.played = true;
else {
soundIndex++;
}
}
}
Using this method, we play a sound only if it has not been played, it has ended, and it
already has the sound file loaded that we need to play. There is no pause to load (most
of the time), and sounds play at pretty much the time that we need them to play. If we
need more sounds, we can load more up front, or we can set MAX_SOUNDS to a number
greater than the number of preloaded sounds. If we do that, we will create new sound
objects on the fly (although this might still give you a pause when loading from a web
server):
if (soundFound) {
tempSound = soundPool[soundIndex].element;
tempSound.volume = volume;
tempSound.play();
else if (soundPool.length < MAX_SOUNDS){
tempSound = document.createElement("audio");
tempSound.setAttribute("src"sound + "." + audioType);
434  |  Chapter 7: Working with Audio
tempSound.volume = volume;
tempSound.play();
soundPool.push({name:soundelement:tempSound, type:audioType
played:true});
}
Go ahead and try this code. It is CH7EX9.html in the code distribution, or you can type
in the program listing.
Other stuff you could do to improve the game
The next couple chapters introduce game concepts, so we really shouldn’t go much
further with Space Raiders. Still, if you were going to finish this game, you might consider
doing the following:
1. Add a score.
2. Increase the aliens’ speed on each new level.
3. Collision-detect the aliens and the player.
4. Make an object pool for missiles and aliens.
5. Slow down firing with a wait() state or frame counter.
6. Add explosions.
7. Include a title sequence, level sequence, and end game sequence.
8. Add a looping soundtrack.
The final code for Space Raiders
Example A-1 shows the final code for the Space Raiders game (CH7EX9.html).
Web Audio API
The Web Audio API is a relatively new specification that allows for more direct access
to the audio playing in the web browser than is possible with the <audio> tag. One day,
this promises to completely alter the way audio is handled in the web browser. However,
at the time of this writing, the Web Audio API is only partially supported in webkit
browsers (Chrome, Chrome for Android, Safari (Mountain Lion), and Safari mobile
(iOS)), and support was only being planned for Firefox. Firefox has its own proprietary
audio API named The Audio Data API. Furthermore, Chrome was the only browser we
could find that worked reliably. Still, it looks like the Web Audio API will become a
future standard, and that is why we are taking a quick look at this emerging technology
in this book.
Web Audio API  |  435
What Is the Web Audio API?
The Web Audio API uses the XMLHttpRequest() functionality of the web browser to
load a sound as an array of binary bytes that is decoded into an audio buffer and then
used to play your sound. An audio buffer is a memory-resident copy of your sound. It
remains in memory, and you can access it as many times and as often as you like without
the need to make multiple copies, using up precious memory. There is no need to create
multiple copies of an audio object, as we did in earlier examples. Using the Web Audio
API promises to one day be the most efficient way to play audio clips in games and
applications.
The Web Audio API specifies that it should be used for short sounds
and audio clips, but music and longer audio should be streamed with
the Audio element.
Space Raiders with the Web Audio API Applied
We are now going to create another version of Space Raiders, this time using the Web
Audio API. The first thing we need to do is to get a reference to the AudioContext object.
However, because the only implementation (at the time of this writing) is in Google
Chrome, we need to use its object for AudioContext, which is webkitAudioContext.
(In theory, this should also work in Safari, but our tests were not successful.)
var audioContext = new webkitAudioContext();
Next we will set up a couple variables to hold the sound buffers for our two sounds
(shoot and explode):
var shootSoundBuffer;
var explodeSoundBuffer;
Now we need to load each sound. To make things straightforward, we will create a
function to load each sound that accepts one parameter, named url, that represents the
location and name of the sound file. In the initApp() function, we will get the audio
Type value as before, but now it will also call our two new functions to load the sounds:
audioType = supportedAudioFormat(tempSound);
loadExplodeSound("explode1." + audioType);
loadShootSound("shoot1."+ audioType);
Next, we need to create the functions that will load the sounds. The first thing the
function needs to do is create an instance of XMLHttpRequest()and configure it for
binary  data.  We  do  this  by  setting  the responseType  of XMLHttpRequest  to
arraybuffer. This is a new way to load data with XMLHttpRequest that allows us to
open binary files, such as audio files.
436  |  Chapter 7: Working with Audio
We then set the onload callback to an inline anonymous function. We will use this to
create a buffer for the sound it has loaded. In that function, we call audioContext.de
codeAudioData() to retrieve the binary loaded data as an audio buffer that we can
reference. That method requires three parameters:
1. The audio data (request.response from the call to XMLHttpRequest)
2. A Success callback (another inline anonymous function that we will describe next)
3. A Failure callback function named onSoundError()
The success callback function receives an argument containing the buffer of the loaded
audio data. We set our variable named shootSoundBuffer to this argument, and we are
ready to play the sound in the game. We then call itemLoaded() so that we can increment
the loadCount variable in the Space Raiders game.
function loadShootSound(url) {
var request = new XMLHttpRequest();
request.open('GET'url, true);
request.responseType = 'arraybuffer';
request.onload = function() {
audioContext.decodeAudioData(request.responsefunction(buffer) {
shootSoundBuffer = buffer;
itemLoaded();
}, onSoundError);
};
request.send();
}
function onSoundError(e) {
alert("error loading sound")
}
We then create a similar function like the above for the “explode” sound. The only
difference is that we set explodeSoundBuffer to the value of the buffer in the success
callback function:
explodeSoundBuffer = buffer;
Now, inside the game when we want to play a sound, we call the playSound() function,
passing the name of the sound buffer we want to play:
playSound(shootSoundBuffer);
The playSound() function is now totally different than the one we created in the pre‐
vious iteration of Space Raiders because we don’t have to manage multiple copies of each
sound. First, we create an instance of AudioBufferSourceNode by calling audioCon
text.createBufferSource() and save it in a variable named source. This object will
hold the sound that we will be playing. We set the buffer property of source to the
buffer that we passed into the function. Again, this buffer represents one of our sounds
Web Audio API  |  437
in memory (shoot or explode). We then call the connect function of audioContext to
set the destination for the sound. For our purposes, we are using the default destination
value, which should be the speakers on your computer. Finally, we call the noteOn()
function of the source, passing 0, which means “start playing immediately.”
You can call the noteOn() function on an instance of AudioBufferSourceNode only
once. After that, it will never play a second time. You need to create another instance if
you want hear the sound again. This is why we don’t save the source after we start playing
it. When the sound is done playing, the browser will garbage collect the reference for
us. There is nothing else we need to do.
function playSound(soundBuffer) {
var source = audioContext.createBufferSource();
source.buffer = soundBuffer;
source.connect(audioContext.destination);
source.noteOn(0);
}
One last thing: we have updated the game to fire automatically. To accomplish this, we
added two variables: shootWaitFrames (the amount to wait before we shoot) and shoot
Wait, a counter that keeps track of how long we have waited before we shoot.
var shootWaitedFrames = 8;
var shootWait = 8;
We also added the following code to drawScreen() to accomplish this. This code makes
the game wait for eight calls to drawScreen() before the player fires a shot. You can alter
shootWaitFrames to make the player fire more or less often. By making this value less,
you can really put the Web Audio API through its paces, with more sounds playing more
often.
shootWaitedFrames++;
if (shootWaitedFrames > shootWait) {
shoot();
shootWaitedFrames = 0;;
}
Google Chrome was the only web browser that supported this example
at the time of publication. Also, the noteOn() function will soon be
deprecated for start().
You can try this new version of Space Raiders by loading CH7EX10.html from the code
distribution. Here are some things to note when you try the example:
1. You need to run this example from a web server; otherwise, XMLHttpRequest()
might not work.
438  |  Chapter 7: Working with Audio
Documents you may be interested
Documents you may be interested