├── README.md
├── css
    ├── GameBoy.css
    └── mobile.css
├── images
    ├── 128.png
    ├── gradient_01.svg
    ├── gradient_02.svg
    ├── gradient_03.svg
    ├── gradient_04.svg
    ├── gradient_05.svg
    ├── gradient_06.svg
    └── speaker.png
├── index.xhtml
├── js
    ├── GameBoyCore.js
    ├── GameBoyIO.js
    └── other
    │   ├── XAudioJS.swf
    │   ├── XAudioServer.js
    │   ├── XAudioServerMediaStreamWorker.js
    │   ├── base64.js
    │   ├── gui.js
    │   ├── json2.js
    │   ├── mobile.js
    │   ├── resampler.js
    │   ├── resize.js
    │   ├── resizeWorker.js
    │   ├── swfobject.js
    │   ├── terminal.js
    │   └── windowStack.js
├── manifest.webapp
└── mobile.html


/README.md:
--------------------------------------------------------------------------------
 1 | JavaScript GameBoy Color Emulator
 2 | =================================
 3 | 
 4 | **Copyright (C) 2010 - 2016 Grant Galitz**
 5 | 
 6 | A GameBoy Color emulator that utilizes HTML5 canvas and JavaScript audio APIs to provide a full emulation of the console.
 7 | 
 8 | **License:**
 9 | 
10 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
15 | 
16 | Known browsers to work well in:
17 | -------------------------------
18 | 
19 | * Firefox 4-27 (Windows 7, Windows Vista, Mac OS X)
20 | * Google Chrome 18+
21 | * Safari 5.1.5+
22 | 
23 | Browsers that suck at performance or fail to run the code correctly:
24 | --------------------------------------------------------------------
25 | 
26 | * Firefox 4+ (*nix versions of Firefox have audio lockup bugs) - Retest this
27 | * Firefox 28+ (Web Audio API creates 500 ms or greater latency, forced by Firefox)
28 | * Opera (Crashes + Slow + Graphics Glitches) - Retest this
29 | * Safari 5.1.X (Below 5.1.5) (Slow or crashes)
30 | * IE 1-8 (Cannot run)
31 | * IE 9-10 (Slow, No native audio support (Requires flash bridge in the audio lib))
32 | * IE 11 (No native audio support (Requires flash bridge in the audio lib))
33 | * Firefox 1-3.6 (Slow)
34 | * ALL VERSIONS OF MOBILE SAFARI AND OPERA (Stop pestering me, iOS just **CAN'T** run this well.)
35 | 
36 | CPU instruction set accuracy test results (Blargg's cpu_instrs.gb test ROM):
37 | -----------------------------------------------------
38 | 
39 | * **GameBoy Online:**
40 | 
41 | 	![GameBoy Online (This emulator)](http://i.imgur.com/ivs7F.png "Passes")
42 | * **Visual Boy Advance 1.7.2:**
43 | 
44 | 	![Visual Boy Advance 1.7.2](http://i.imgur.com/NYnYu.png "Fails")
45 | * **KiGB:**
46 | 
47 | 	![KiGB](http://i.imgur.com/eYHDH.png "Fails")
48 | * **Gambatte:**
49 | 
50 | 	![Gambatte](http://i.imgur.com/vGHFz.png "Passes")
51 | 


--------------------------------------------------------------------------------
/css/GameBoy.css:
--------------------------------------------------------------------------------
  1 | @charset "utf-8";
  2 | html {
  3 | 	background-color: rgb(200, 225, 225);
  4 | 	background-attachment: fixed;
  5 | 	background-repeat: none;
  6 | 	background-image: url("../images/gradient_01.svg");
  7 | 	background-image: -webkit-linear-gradient(315deg, rgb(200, 200, 255), rgb(200, 255, 200));
  8 | 	background-image: -moz-linear-gradient(315deg, rgb(200, 200, 255), rgb(200, 255, 200));
  9 | 	background-image: -o-linear-gradient(315deg, rgb(200, 200, 255), rgb(200, 255, 200));
 10 | 	background-image: linear-gradient(135deg, rgb(200, 200, 255), rgb(200, 255, 200));
 11 | 	margin: 0;
 12 | 	padding: 0;
 13 | 	font-family: arial;
 14 | 	margin: 0;
 15 | 	padding: 0;
 16 | 	overflow: auto;
 17 | 	text-align: left;
 18 | 	direction: ltr;
 19 | 	width: 100%;
 20 | 	height: 100%;
 21 | 	text-rendering: optimizeSpeed;
 22 | }
 23 | body {
 24 | 	width: auto;
 25 | 	height: auto;
 26 | 	min-width: 100%;
 27 | 	min-height: 100%;
 28 | 	border: none;
 29 | 	margin: 0;
 30 | 	padding: 0;
 31 | }
 32 | div.menubar, div#GameBoy > div#gfx, div.window > div.button_rack, ul.menu {
 33 | 	-webkit-text-size-adjust: none;
 34 | 	-webkit-tap-highlight-color: transparent;
 35 | 	-webkit-touch-callout: none;
 36 | 	-webkit-user-select: none;
 37 | 	-moz-user-select: none;
 38 | 	-khtml-user-select: none;
 39 | 	user-select: none;
 40 | }
 41 | div.window {
 42 | 	visibility: visible;
 43 | 	display: none;
 44 | 	position: absolute;
 45 | 	overflow: hidden;
 46 | 	margin: 0;
 47 | 	padding: 10px 0px 0px 0px;
 48 | 	top: 0;
 49 | 	left: 0;
 50 | 	color: rgb(0, 0, 0);
 51 | 	font-size: 16px;
 52 | 	-webkit-border-radius: 10px 10px 3px 3px;
 53 | 	border-radius: 10px 10px 3px 3px;
 54 | 	-webkit-box-shadow: 5px 5px 10px rgb(30, 30, 30);
 55 | 	box-shadow: 5px 5px 10px rgb(30, 30, 30);
 56 | 	background-color: rgb(200, 200, 200);
 57 | 	z-index: 2;
 58 | 	opacity: 1;
 59 | }
 60 | div#GameBoy {
 61 | 	min-height: 340px;
 62 | 	min-width: 400px;
 63 | }
 64 | div#input_select, div#save_importer {
 65 | 	min-height: 100px;
 66 | 	min-width: 200px;
 67 | }
 68 | div#instructions {
 69 | 	min-height: 300px;
 70 | 	min-width: 400px;
 71 | }
 72 | div.menubar {
 73 | 	max-height: 28px;
 74 | 	min-width: 250px;	/*Fail safe for poopy browsers.*/
 75 | 	display: block;
 76 | 	overflow: hidden;
 77 | 	position: absolute;
 78 | 	left: 0;
 79 | 	right: 0;
 80 | 	border-top-style: solid;
 81 | 	border-top-width: 1px;
 82 | 	border-top-color: rgb(150, 150, 150);
 83 | 	border-left-style: none;
 84 | 	border-right-style: none;
 85 | 	border-bottom-style: solid;
 86 | 	border-bottom-width: 1px;
 87 | 	border-bottom-color: rgb(50, 50, 50);
 88 | 	text-overflow: ellipsis;
 89 | 	margin: 0;
 90 | 	padding: 0 0 0 3px;
 91 | 	text-align: left;
 92 | 	background-color: rgb(210, 210, 210);
 93 | 	background-repeat: repeat-x;
 94 | 	background-attachment: scroll;
 95 | 	background-image: url("../images/gradient_02.svg");
 96 | 	background-image: -webkit-linear-gradient(top, rgb(150, 150, 150), rgb(220, 220, 220), rgb(180, 180, 180));
 97 | 	background-image: -moz-linear-gradient(top, rgb(150, 150, 150), rgb(220, 220, 220), rgb(180, 180, 180));
 98 | 	background-image: -o-linear-gradient(top, rgb(150, 150, 150), rgb(220, 220, 220), rgb(180, 180, 180));
 99 | 	background-image: linear-gradient(top, rgb(150, 150, 150), rgb(220, 220, 220), rgb(180, 180, 180));
100 | }
101 | div.menubar > span {
102 | 	cursor: pointer;
103 | 	-webkit-border-radius: 5px;
104 | 	border-radius: 5px;
105 | 	background-color: transparent;
106 | 	padding: 2px 5px;
107 | 	margin: 3px 3px 3px 0;
108 | 	display: inline;
109 | 	display: inline-block;
110 | }
111 | div.menubar > span:hover {
112 | 	-webkit-box-shadow: 2px 2px 1px rgb(30, 30, 30);
113 | 	box-shadow: 2px 2px 1px rgb(30, 30, 30);
114 | 	background-color: rgb(160, 160, 160);
115 | 	background-repeat: repeat-x;
116 | 	background-attachment: scroll;
117 | 	background-image: url("../images/gradient_03.svg");
118 | 	background-image: -webkit-linear-gradient(top, rgb(160, 160, 160), rgb(190, 190, 190), rgb(160, 160, 160));
119 | 	background-image: -moz-linear-gradient(top, rgb(160, 160, 160), rgb(190, 190, 190), rgb(160, 160, 160));
120 | 	background-image: -o-linear-gradient(top, rgb(160, 160, 160), rgb(190, 190, 190), rgb(160, 160, 160));
121 | 	background-image: linear-gradient(top, rgb(160, 160, 160), rgb(190, 190, 190), rgb(160, 160, 160));
122 | }
123 | div.menubar > span:active {
124 | 	-webkit-box-shadow: inset 2px 2px 1px rgb(30, 30, 30);
125 | 	box-shadow: inset 2px 2px 1px rgb(30, 30, 30);
126 | 	background-color: rgb(220, 220, 220);
127 | 	background-repeat: repeat-x;
128 | 	background-attachment: scroll;
129 | 	background-image: url("../images/gradient_04.svg");
130 | 	background-image: -webkit-linear-gradient(top, rgb(190, 190, 190), rgb(160, 160, 160), rgb(190, 190, 190));
131 | 	background-image: -moz-linear-gradient(top, rgb(190, 190, 190), rgb(160, 160, 160), rgb(190, 190, 190));
132 | 	background-image: -o-linear-gradient(top, rgb(190, 190, 190), rgb(160, 160, 160), rgb(190, 190, 190));
133 | 	background-image: linear-gradient(top, rgb(190, 190, 190), rgb(160, 160, 160), rgb(190, 190, 190));
134 | }
135 | div#gfx {
136 | 	height: auto;
137 | 	width: auto;
138 | 	margin: 0;
139 | 	padding: 0;
140 | 	position: absolute;
141 | 	bottom: 3px;
142 | 	left: 3px;
143 | 	right: 3px;
144 | 	top: 43px;
145 | 	background-color: rgb(200, 50, 50);
146 | 	background-repeat: repeat-x;
147 | 	background-attachment: scroll;
148 | 	background-image: url("../images/gradient_05.svg");
149 | 	background-image: -webkit-linear-gradient(top, rgb(200, 50, 50), rgb(200, 75, 150));
150 | 	background-image: -moz-linear-gradient(top, rgb(200, 50, 50), rgb(200, 75, 150));
151 | 	background-image: -o-linear-gradient(top, rgb(200, 50, 50), rgb(200, 75, 150));
152 | 	background-image: linear-gradient(top, rgb(200, 50, 50), rgb(200, 75, 150));
153 | }
154 | body > div#fullscreenContainer {
155 | 	position: absolute;	/*Fallback here if fixed isn't supported*/
156 | 	position: fixed;
157 | 	height: 100%;
158 | 	width: 100%;
159 | 	left: 0;
160 | 	right: 0;
161 | 	top: 0;
162 | 	bottom: 0px;
163 | 	background-color: rgb(0, 0, 0);
164 | 	display: none;
165 | 	z-index: 100;
166 | }
167 | body > div#fullscreenContainer > canvas#fullscreen.maximum {
168 | 	position: static;
169 | 	height: 100%;
170 | 	width: 100%;
171 | 	margin: 0;
172 | 	padding: 0;
173 | }
174 | body > div#fullscreenContainer > canvas#fullscreen.minimum {
175 | 	position: absolute;
176 | 	height: 144px;
177 | 	width: 160px;
178 | 	top: 50%;
179 | 	left: 50%;
180 | 	margin: -72px 0 0 -80px;
181 | 	padding: 0;
182 | }
183 | div#GameBoy > div#gfx > canvas {
184 | 	position: absolute;
185 | 	z-index: 5;
186 | 	visibility: hidden;
187 | 	top: 0;
188 | 	left: 0;
189 | 	right: 0;
190 | 	bottom: 0;
191 | 	width: 100%;
192 | 	height: 100%;
193 | 	background-color: rgb(255, 255, 255);
194 | }
195 | div#GameBoy > div#gfx > span#title {
196 | 	position: absolute;
197 | 	top: 30%;
198 | 	left: 15%;
199 | 	font-size: 64px;
200 | 	color: rgb(220, 220, 150);
201 | 	text-shadow: 3px 3px 5px rgb(50, 50, 50);
202 | 	font-style: italic;
203 | 	z-index: 1;
204 | 	padding: 0 5px 0 0;
205 | }
206 | div#GameBoy > div#gfx > span#port_title {
207 | 	position: absolute;
208 | 	top: 45%;
209 | 	left: 55%;
210 | 	font-size: 32px;
211 | 	color: rgb(180, 70, 70);
212 | 	text-shadow: 2px 2px 4px rgb(80, 80, 80);
213 | 	font-style: italic;
214 | 	font-weight: bold;
215 | 	z-index: 2;
216 | 	padding: 0 5px 0 0;
217 | }
218 | div#about {
219 | 	max-width: 400px;
220 | 	max-height: 350px;
221 | 	min-width: 400px;
222 | 	min-height: 350px;
223 | }
224 | div#terminal {
225 | 	min-height: 100px;
226 | 	min-width: 310px;
227 | }
228 | div#terminal, div#about, div#settings, div#local_storage_listing, div#freeze_listing {
229 | 	height: 350px;
230 | 	width: 400px;
231 | }
232 | div#settings {
233 | 	height: 410px;
234 | }
235 | div#local_storage_popup {
236 | 	height: 250px;
237 | 	width: 300px;
238 | }
239 | div#local_storage_listing, div#freeze_listing {
240 | 	min-width: 400px;
241 | 	min-height: 350px;
242 | }
243 | div.storageList {
244 | 	position: absolute;
245 | 	top: 10px;
246 | 	left: 3px;
247 | 	right: 4px;
248 | 	overflow: auto;
249 | 	text-align: left;
250 | 	bottom: 50px;
251 | 	background-color: rgb(140, 140, 140);
252 | 	-webkit-border-radius: 3px;
253 | 	border-radius: 3px;
254 | 	-webkit-box-shadow: inset 3px 3px 2px 1px rgb(110, 110, 110);
255 | 	box-shadow: inset 3px 3px 2px 1px rgb(110, 110, 110);
256 | 	padding: 3px;
257 | }
258 | div#storageListingMasterContainer {
259 | 	top: 40px !important;
260 | }
261 | div#download_all_storage {
262 | 	position: absolute;
263 | 	height: 20px;
264 | 	left: 3px;
265 | 	top: 10px;
266 | 	right: 4px;
267 | 	text-align: center;
268 | 	font-style: bold;
269 | 	background-color: rgb(140, 140, 140);
270 | 	-webkit-border-radius: 3px;
271 | 	border-radius: 3px;
272 | 	-webkit-box-shadow: inset 3px 3px 2px 1px rgb(110, 110, 110);
273 | 	box-shadow: inset 3px 3px 2px 1px rgb(110, 110, 110);
274 | 	padding: 3px;
275 | }
276 | div.storageList a, div#download_all_storage a {
277 | 	color: rgb(210, 210, 210);
278 | }
279 | div#terminal > div#terminal_output {
280 | 	background-color: rgb(0, 0, 0);
281 | 	margin: 0;
282 | 	padding: 0;
283 | 	font-family: monotype;
284 | 	font-size: 12px;
285 | 	bottom: 50px;
286 | 	padding: 10px;
287 | 	top: 10px;
288 | 	right: 3px;
289 | 	left: 3px;
290 | 	position: absolute;
291 | 	cursor: crosshair;
292 | 	overflow: auto;
293 | 	text-align: left;
294 | }
295 | div#terminal > div#terminal_output > span.white {
296 | 	color: rgb(255, 255, 255);
297 | }
298 | div#terminal > div#terminal_output > span.white:before {
299 | 	content: "<DEBUG> ";
300 | 	font-weight: bold;
301 | }
302 | div#terminal > div#terminal_output > span.yellow {
303 | 	color: rgb(255, 255, 0);
304 | }
305 | div#terminal > div#terminal_output > span.yellow:before {
306 | 	content: "<WARNING> ";
307 | 	font-weight: bold;
308 | }
309 | div#terminal > div#terminal_output > span.red {
310 | 	color: rgb(0, 0, 255);
311 | }
312 | div#terminal > div#terminal_output > span.red:before {
313 | 	content: "<ERROR> ";
314 | 	font-weight: bold;
315 | }
316 | div#about > div#about_message, div#instructions > div#keycodes {
317 | 	position: absolute;
318 | 	top: 10px;
319 | 	left: 3px;
320 | 	bottom: 50px;
321 | 	right: 3px;
322 | 	background-color: rgb(230, 230, 230);
323 | 	border-width: 5px;
324 | 	border-style: groove;
325 | 	border-color: rgb(50, 50, 50);
326 | 	padding: 5px;
327 | 	overflow: auto;
328 | }
329 | div#about > div#about_message > h1 {
330 | 	font-size: 20px;
331 | 	color: rgb(80, 60, 20);
332 | }
333 | div#settings > div#toggle_settings {
334 | 	position: absolute;
335 | 	top: 10px;
336 | 	left: 3px;
337 | 	right: 3px;
338 | 	bottom: 50px;
339 | }
340 | div#settings > div#toggle_settings > div.setting {
341 | 	text-align: left;
342 | 	width: 100%;
343 | 	position: relative;
344 | 	margin: 0;
345 | 	padding: 0 0 3px 0;
346 | 	border: none;
347 | }
348 | div#settings > div#toggle_settings > div.setting:hover {
349 | 	border-bottom-style: dashed;
350 | 	border-bottom-color: rgb(70, 70, 70);
351 | 	border-bottom-width: 1px;
352 | }
353 | div#settings > div#toggle_settings > div.setting input {
354 | 	float: right;
355 | }
356 | div.window > div.button_rack {
357 | 	background-color: transparent;
358 | 	margin: 0;
359 | 	padding: 0;
360 | 	position: absolute;
361 | 	height: 44px;
362 | 	bottom: 3px;
363 | 	right: 3px;
364 | 	left: 3px;
365 | 	text-align: center;
366 | }
367 | div.window > div.button_rack > button {
368 | 	cursor: pointer;
369 | 	padding: 0;
370 | 	margin: 0;
371 | 	height: 44px;
372 | 	width: 150px;
373 | 	text-align: center;
374 | 	font-size: 14px;
375 | 	position: relative;
376 | }
377 | div.window > div.button_rack > button.left {
378 | 	float: left;
379 | }
380 | div.window > div.button_rack > button.right {
381 | 	float: right;
382 | }
383 | div.window > div.button_rack > button.center {
384 | 	width: 100%;
385 | }
386 | ul.menu {
387 | 	list-style-position: inside;
388 | 	position: absolute;
389 | 	display: none;
390 | 	list-style-type: none;
391 | 	width: auto;
392 | 	height: auto;
393 | 	margin: 0;
394 | 	padding: 0;
395 | 	top: 0;
396 | 	left: 0;
397 | 	z-index: 3;
398 | 	background-color: rgb(200, 200, 200);
399 | 	background-repeat: repeat-x;
400 | 	background-attachment: scroll;
401 | 	background-image: url("../images/gradient_06.svg");
402 | 	background-image: -webkit-linear-gradient(left, rgb(200, 200, 200), rgb(240, 240, 240));
403 | 	background-image: -moz-linear-gradient(left, rgb(200, 200, 200), rgb(240, 240, 240));
404 | 	background-image: -o-linear-gradient(left, rgb(200, 200, 200), rgb(240, 240, 240));
405 | 	background-image: linear-gradient(left, rgb(200, 200, 200), rgb(240, 240, 240));
406 | 	-webkit-border-radius: 3px;
407 | 	border-radius: 3px;
408 | 	-webkit-box-shadow: 5px 5px 10px rgb(30, 30, 30);
409 | 	box-shadow: 5px 5px 10px rgb(30, 30, 30);
410 | 	border-style: solid;
411 | 	border-top-width: 1px;
412 | 	border-left-width: 1px;
413 | 	border-right-width: 2px;
414 | 	border-bottom-width: 2px;
415 | 	border-top-color: rgb(100, 100, 100);
416 | 	border-left-color: rgb(100, 100, 100);
417 | 	border-bottom-color: rgb(50, 50, 50);
418 | 	border-right-color: rgb(50, 50, 50);
419 | 	overflow: visible;
420 | }
421 | ul.menu:hover {
422 | 	display: block;
423 | 	display: inline-block;
424 | 	top: 0;
425 | 	left: 0;
426 | }
427 | ul.menu > li {
428 | 	display: block;
429 | 	position: relative;
430 | 	margin: 0 0 -1px 0;	/*Firefox DOM mouseover bug*/
431 | 	padding: 2px 5px 2px 15px;
432 | 	color: rgb(0, 0, 0);
433 | 	background-color: transparent;
434 | 	width: 200px;
435 | 	height: auto;
436 | 	border: none;
437 | 	overflow: visible;
438 | 	text-overflow: ellipsis;
439 | }
440 | ul.menu > li:hover {
441 | 	background-color: transparent;
442 | 	background-color: rgb(255, 255, 200);
443 | 	background-color: rgba(255, 255, 200, 0.3);
444 | }
445 | ul.menu > li:hover > ul.menu {
446 | 	left: 220px;
447 | 	top: 0;
448 | 	display: block;
449 | 	display: inline-block;
450 | }


--------------------------------------------------------------------------------
/css/mobile.css:
--------------------------------------------------------------------------------
  1 | html, body {
  2 |   margin: 0;
  3 |   padding: 0;
  4 |   width: 100%;
  5 |   height: 100%;
  6 |   background-color: black;
  7 |   font-family: Verdana;
  8 | }
  9 | 
 10 | #gameboy_shell {
 11 |   height: 100%;
 12 |   min-height: 480px;
 13 |   min-width: 320px;
 14 |   border-top-left-radius: 15px;
 15 |   border-top-right-radius: 15px;
 16 |   border-bottom-left-radius: 15px;
 17 |   border-bottom-right-radius: 45px;
 18 |   box-shadow: inset -15px 16px 6px -12px rgba(255,255,255, 0.5), inset 15px -11px 6px -11px rgba(0,0,0,0.5);
 19 | }
 20 | 
 21 | #on_off {
 22 |   margin-left: 10%;
 23 |   font-size: 10pt;
 24 |   text-shadow: 0px 0px 2px #000;
 25 | }
 26 | 
 27 | #screen_cover {
 28 |   background-color: #525E59;
 29 |   width: 80%;
 30 |   height: 40%;
 31 |   margin: 0 auto;
 32 |   border: 1px solid black;
 33 |   border-top-left-radius: 5px;
 34 |   border-top-right-radius: 5px;
 35 |   border-bottom-left-radius: 5px;
 36 |   border-bottom-right-radius: 30px;
 37 | }
 38 | 
 39 | #power {
 40 |   float: left;
 41 |   position: relative;
 42 |   top: 30%;
 43 |   font-size: 8pt;
 44 |   color: white;
 45 |   padding-left: 5px;
 46 | }
 47 | 
 48 | .two_column {
 49 |   width: 30px;
 50 |   height: 15px;
 51 | }
 52 | 
 53 | #power_light {
 54 |   float: left;
 55 |   position: static;
 56 |   width: 10px;
 57 |   height: 10px;
 58 |   background-color: red;
 59 |   margin-left: 5px;
 60 |   margin-top: 2px;
 61 |   border-radius: 10px;
 62 | }
 63 | 
 64 | #power_light +div {
 65 |   float: right;
 66 | }
 67 | 
 68 | #canvas_container {
 69 |   width: 160px;
 70 |   margin: 20px auto 0 auto;
 71 | }
 72 | 
 73 | #screen_cover > div:last-child {
 74 |   position: relative;
 75 |   left: 15%;
 76 |   width: 120px;
 77 |   font-size: 10pt;
 78 |   text-align: center;
 79 |   color: white;
 80 |   font-style: oblique;
 81 | }
 82 | 
 83 | #pocket {
 84 |   color: #525E59;
 85 |   background-color: white;
 86 |   font-size: 8pt;
 87 | }
 88 | 
 89 | #nintendo {
 90 |   border-radius: 10px;
 91 |   width: 25%;
 92 |   text-align: center;
 93 |   margin: 10px auto 0 auto;
 94 |   padding: 0 5px;
 95 |   text-shadow: 0px 0px 2px #000;
 96 |   box-shadow: 0px 0px 2px #000, inset 0px 0px 2px #000;
 97 | }
 98 | 
 99 | #d_pad {
100 |   width: 70px;
101 |   height: 70px;
102 |   position: relative;
103 |   top: 20px;
104 |   left: 10%;
105 | }
106 | 
107 | #d_pad > div {
108 |   background-color: #525E59;
109 | }
110 | 
111 | #d_pad_up {
112 |   box-shadow: inset -15px 10px 10px -12px rgba(255,255,255, 0.5), inset 15px -11px 6px -11px rgba(0,0,0,0.5);
113 |   border-top-left-radius: 5px;
114 |   border-top-right-radius: 5px;
115 |   width: 33%;
116 |   height: 33%;
117 |   margin: 0 auto;
118 | }
119 | 
120 | #d_pad_left_right {
121 |   box-shadow: inset -15px 10px 10px -12px rgba(255,255,255, 0.5), inset 15px -11px 6px -11px rgba(0,0,0,0.5);
122 |   border-radius: 5px;
123 |   height: 33%;
124 |   margin: 0 auto;
125 | }
126 | 
127 | #d_pad_down {
128 |   box-shadow: inset -15px 10px 10px -12px rgba(255,255,255, 0.5), inset 15px -11px 6px -11px rgba(0,0,0,0.5);
129 |   border-bottom-left-radius: 5px;
130 |   border-bottom-right-radius: 5px;
131 |   width: 33%;
132 |   height: 33%;
133 |   margin: 0 auto;
134 | }
135 | 
136 | #d_pad_left {
137 |   width: 33%;
138 |   height: 100%;
139 |   float: left;
140 | }
141 | 
142 | #d_pad_center {
143 |   border: 1px solid black;
144 |   height: 20px;
145 |   width: 20px;
146 |   margin: 0 auto;
147 |   border-radius: 20px;
148 |   /*box-shadow: inset 5px -5px 6px 0px rgba(255,255,255, 0.5);*/
149 |   box-shadow: inset -15px 10px 10px -12px rgba(0,0,0, 0.5), inset 15px -11px 6px -11px rgba(255,255,255,0.5);
150 | }
151 | 
152 | #d_pad_right {
153 |   width: 33%;
154 |   height: 100%;
155 |   float: right;
156 | }
157 | 
158 | #arrow_up, #arrow_down, #arrow_left, #arrow_right {
159 |   width: 0;
160 |   height: 0;
161 |   margin: 0 auto;
162 | }
163 | 
164 | #arrow_up {
165 |   border-left: 10px solid transparent;
166 |   border-right: 10px solid transparent;
167 |   border-bottom: 20px solid black;
168 | }
169 | 
170 | #arrow_left {
171 |   border-top: 10px solid transparent;
172 |   border-right: 20px solid black;
173 |   border-bottom: 10px solid transparent;
174 | }
175 | 
176 | #arrow_right {
177 |   border-left: 20px solid black;
178 |   border-top: 10px solid transparent;
179 |   border-bottom: 10px solid transparent;
180 | }
181 | #arrow_down {
182 |   border-left: 10px solid transparent;
183 |   border-right: 10px solid transparent;
184 |   border-top: 20px solid black;
185 | }
186 | 
187 | #a_button_group {
188 |   left: 75%;
189 |   top: 55%;
190 | }
191 | 
192 | #b_button_group {
193 |   left: 55%;
194 |   top: 60%;
195 | }
196 | 
197 | #select_button_group {
198 |   left: 33%;
199 |   top: 85%;
200 | }
201 | 
202 | #start_button_group {
203 |   right: 33%;
204 |   top: 85%
205 | }
206 | 
207 | .button_group {
208 |   position: absolute;
209 |   text-align: center;
210 |   color: #525E59;
211 |   font-size: 10pt;
212 | }
213 | 
214 | .button_group div {
215 |   width: 40px;
216 |   background-color: #525E59;
217 |   border-radius: 20px;
218 |   margin: 0 auto 10px auto;
219 |   box-shadow: inset -15px 10px 10px -12px rgba(255,255,255, 0.5), inset 15px -11px 6px -11px rgba(0,0,0,0.5);
220 | }
221 | 
222 | .button_group .round_button {
223 |   height: 40px;
224 | }
225 | 
226 | .button_group .flat_button {
227 |   height: 15px;
228 | }
229 | 
230 | #speaker {
231 |   position: relative;
232 |   left: 70%;
233 |   top: 15%;
234 | }
235 | 


--------------------------------------------------------------------------------
/images/128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/taisel/GameBoy-Online/47f9f638a8a9445aaa75050f634e437baa34aae0/images/128.png


--------------------------------------------------------------------------------
/images/gradient_01.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="100%" y2="100%">
 6 | 			<stop offset="0%" style="stop-color:rgb(200, 200, 255); stop-opacity:1"/>
 7 | 			<stop offset="100%" style="stop-color:rgb(200, 255, 200); stop-opacity:1"/>
 8 | 		</linearGradient>
 9 | 	</defs>
10 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
11 | </svg>


--------------------------------------------------------------------------------
/images/gradient_02.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="0%" y2="100%">
 6 | 			<stop offset="0%" style="stop-color:rgb(150, 150, 150); stop-opacity:1"/>
 7 | 			<stop offset="50%" style="stop-color:rgb(220, 220, 220); stop-opacity:1"/>
 8 | 			<stop offset="100%" style="stop-color:rgb(180, 180, 180); stop-opacity:1"/>
 9 | 		</linearGradient>
10 | 	</defs>
11 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
12 | </svg>


--------------------------------------------------------------------------------
/images/gradient_03.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="0%" y2="100%">
 6 | 			<stop offset="0%" style="stop-color:rgb(160, 160, 160); stop-opacity:1"/>
 7 | 			<stop offset="50%" style="stop-color:rgb(190, 190, 190); stop-opacity:1"/>
 8 | 			<stop offset="100%" style="stop-color:rgb(160, 160, 160); stop-opacity:1"/>
 9 | 		</linearGradient>
10 | 	</defs>
11 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
12 | </svg>


--------------------------------------------------------------------------------
/images/gradient_04.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="0%" y2="100%">
 6 | 			<stop offset="0%" style="stop-color:rgb(190, 190, 190); stop-opacity:1"/>
 7 | 			<stop offset="50%" style="stop-color:rgb(160, 160, 160); stop-opacity:1"/>
 8 | 			<stop offset="100%" style="stop-color:rgb(190, 190, 190); stop-opacity:1"/>
 9 | 		</linearGradient>
10 | 	</defs>
11 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
12 | </svg>


--------------------------------------------------------------------------------
/images/gradient_05.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="0%" y2="100%">
 6 | 			<stop offset="0%" style="stop-color:rgb(200, 50, 50); stop-opacity:1"/>
 7 | 			<stop offset="100%" style="stop-color:rgb(200, 75, 150); stop-opacity:1"/>
 8 | 		</linearGradient>
 9 | 	</defs>
10 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
11 | </svg>


--------------------------------------------------------------------------------
/images/gradient_06.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" version="1.1" xmlns="http://www.w3.org/2000/svg">
 4 | 	<defs>
 5 | 		<linearGradient id="gradient" x1="0%" y1="0%" x2="100%" y2="0%">
 6 | 			<stop offset="0%" style="stop-color:rgb(200, 200, 200); stop-opacity:1"/>
 7 | 			<stop offset="100%" style="stop-color:rgb(240, 240, 240); stop-opacity:1"/>
 8 | 		</linearGradient>
 9 | 	</defs>
10 | 	<rect x="0" y="0" width="100%" height="100%" style="fill:url(#gradient)"/>
11 | </svg>


--------------------------------------------------------------------------------
/images/speaker.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/taisel/GameBoy-Online/47f9f638a8a9445aaa75050f634e437baa34aae0/images/speaker.png


--------------------------------------------------------------------------------
/index.xhtml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <!DOCTYPE html>
  3 | <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
  4 |     <head>
  5 |         <style type="text/css">@import url(&quot;css/GameBoy.css&quot;);</style>
  6 |         <script type="text/javascript">
  7 |     var DEBUG_MESSAGES = false;
  8 |     var DEBUG_WINDOWING = false;
  9 |     window.onload = function () {
 10 |         windowingInitialize();
 11 |     }
 12 |         </script>
 13 |         <script type="text/javascript" src="js/other/windowStack.js"/>
 14 |         <script type="text/javascript" src="js/other/terminal.js"/>
 15 |         <script type="text/javascript" src="js/other/gui.js"/>
 16 |         <script type="text/javascript" src="js/other/base64.js"/>
 17 |         <script type="text/javascript" src="js/other/json2.js"/>
 18 |         <script type="text/javascript" src="js/other/swfobject.js"/>
 19 |         <script type="text/javascript" src="js/other/resampler.js"/>
 20 |         <script type="text/javascript" src="js/other/XAudioServer.js"/>
 21 |         <script type="text/javascript" src="js/other/resize.js"/>
 22 |         <script type="text/javascript" src="js/GameBoyCore.js"/>
 23 |         <script type="text/javascript" src="js/GameBoyIO.js"/>
 24 |         <title>GameBoy Online</title>
 25 |     </head>
 26 |     <body>
 27 |         <div id="GameBoy" class="window">
 28 |             <div class="menubar">
 29 |                 <span id="GameBoy_file_menu">File</span>
 30 |                 <span id="GameBoy_settings_menu">Settings</span>
 31 |                 <span id="GameBoy_view_menu">View</span>
 32 |                 <span id="GameBoy_about_menu">About</span>
 33 |             </div>
 34 |             <div id="gfx">
 35 |                 <canvas id="mainCanvas"/>
 36 |                 <span id="title">GameBoy</span>
 37 |                 <span id="port_title">Online</span>
 38 |             </div>
 39 |         </div>
 40 |         <div id="terminal" class="window">
 41 |             <div id="terminal_output"/>
 42 |             <div class="button_rack">
 43 |                 <button id="terminal_clear_button" class="left">Clear Messages</button>
 44 |                 <button id="terminal_close_button" class="right">Close Terminal</button>
 45 |             </div>
 46 |         </div>
 47 |         <div id="about" class="window">
 48 |             <div id="about_message">
 49 |                 <h1>GameBoy Online</h1>
 50 |                 <p>This is a GameBoy Color emulator written purely in JavaScript by Grant Galitz.</p><p>The graphics blitting is done through HTML5 canvas, with the putImageData and drawImage functions.</p><p>Save states are implemented through the window.localStorage object, and are serialized/deserialized through JSON. SRAM saving is also implemented through the window.localStorage object, and are serialized/deserialized through JSON. In order for save states to work properly on most browsers, you need set the maximum size limit for DOM storage higher, to meet the needs of the emulator's save data size.</p><p>For more information about this emulator and its source code, visit the GIT repository at: <a href="https://github.com/taisel/GameBoy-Online" target="_blank">https://github.com/taisel/GameBoy-Online</a>.
 51 |                 </p>
 52 |             </div>
 53 |             <div class="button_rack">
 54 |                 <button id="about_close_button" class="center">Close Popup</button>
 55 |             </div>
 56 |         </div>
 57 |         <div class="window" id="settings">
 58 |             <div id="toggle_settings">
 59 |                 <div class="setting">
 60 |                     <span>Enable Sound:</span>
 61 |                     <input type="checkbox" checked="checked" id="enable_sound"/>
 62 |                 </div>
 63 |                 <div class="setting">
 64 |                     <span>GB mode has priority over GBC mode:</span>
 65 |                     <input type="checkbox" id="disable_colors"/>
 66 |                 </div>
 67 |                 <div class="setting">
 68 |                     <span>Use the BIOS ROM:</span>
 69 |                     <input type="checkbox" checked="checked" id="enable_gbc_bios"/>
 70 |                 </div>
 71 |                 <div class="setting">
 72 |                     <span>Override ROM only cartridge typing to MBC1:</span>
 73 |                     <input type="checkbox" checked="checked" id="rom_only_override"/>
 74 |                 </div>
 75 |                 <div class="setting">
 76 |                     <span>Always allow reading and writing to the MBC banks:</span>
 77 |                     <input type="checkbox" checked="checked" id="mbc_enable_override"/>
 78 |                 </div>
 79 |                 <div class="setting">
 80 |                     <span>Colorize Classic GameBoy Palettes:</span>
 81 |                     <input type="checkbox" checked="checked" id="enable_colorization"/>
 82 |                 </div>
 83 |                 <div class="setting">
 84 |                     <span>Minimal view on fullscreen:</span>
 85 |                     <input type="checkbox" checked="checked" id="do_minimal"/>
 86 |                 </div>
 87 |                 <div class="setting">
 88 |                     <span>Resize canvas directly in JavaScript:</span>
 89 |                     <input type="checkbox" id="software_resizing"/>
 90 |                 </div>
 91 |                 <div class="setting">
 92 |                     <span>Disallow typed arrays to be used:</span>
 93 |                     <input type="checkbox" id="typed_arrays_disallow"/>
 94 |                 </div>
 95 |                 <div class="setting">
 96 |                     <span>Use the DMG boot ROM instead of CGB:</span>
 97 |                     <input type="checkbox" id="gb_boot_rom_utilized"/>
 98 |                 </div>
 99 |                 <div class="setting">
100 |                     <span>Smooth upon resizing canvas:</span>
101 |                     <input type="checkbox" checked="checked" id="resize_smoothing"/>
102 |                 </div>
103 |                 <div class="setting">
104 |                     <span>Enable Channel 1 Audio:</span>
105 |                     <input type="checkbox" checked="checked" id="channel1"/>
106 |                 </div>
107 |                 <div class="setting">
108 |                     <span>Enable Channel 2 Audio:</span>
109 |                     <input type="checkbox" checked="checked" id="channel2"/>
110 |                 </div>
111 |                 <div class="setting">
112 |                     <span>Enable Channel 3 Audio:</span>
113 |                     <input type="checkbox" checked="checked" id="channel3"/>
114 |                 </div>
115 |                 <div class="setting">
116 |                     <span>Enable Channel 4 Audio:</span>
117 |                     <input type="checkbox" checked="checked" id="channel4"/>
118 |                 </div>
119 |             </div>
120 |             <div class="button_rack">
121 |                 <button id="settings_close_button" class="center">Close Settings</button>
122 |             </div>
123 |         </div>
124 |         <div id="instructions" class="window">
125 |             <div id="keycodes">
126 |                 <h1>Keyboard Controls:</h1>
127 |                 <ul>
128 |                     <li>X/J are A.</li>
129 |                     <li>Z/Y/Q are B.</li>
130 |                     <li>Shift is Select.</li>
131 |                     <li>Enter is Start.</li>
132 |                     <li>The d-pad is the control pad.</li>
133 |                     <li>The escape key (esc) allows you to get in and out of fullscreen mode.</li>
134 |                 </ul>
135 |             </div>
136 |             <div class="button_rack">
137 |                 <button id="instructions_close_button" class="center">Close Instructions</button>
138 |             </div>
139 |         </div>
140 |         <div id="input_select" class="window">
141 |             <form>
142 |                 <input type="file" id="local_file_open"/>
143 |             </form>
144 |             <div class="button_rack">
145 |                 <button id="input_select_close_button" class="center">Close File Input</button>
146 |             </div>
147 |         </div>
148 |         <div id="save_importer" class="window">
149 |             <form>
150 |                 <input type="file" id="save_open"/>
151 |             </form>
152 |             <div class="button_rack">
153 |                 <button id="save_importer_close_button" class="center">Close Save Importer</button>
154 |             </div>
155 |         </div>
156 |         <div class="window" id="local_storage_listing">
157 |             <div id="storageListingMasterContainer" class="storageList">
158 |                 <div id="storageListingMasterContainerSub"/>
159 |             </div>
160 |             <div id="download_all_storage">
161 |                 <a href="about:blank" id="download_local_storage_dba">Export all saved data.</a>
162 |             </div>
163 |             <div class="button_rack">
164 |                 <button id="local_storage_list_refresh_button" class="left">Refresh List</button>
165 |                 <button id="local_storage_list_close_button" class="right">Close Storage List</button>
166 |             </div>
167 |         </div>
168 |         <div class="window" id="local_storage_popup">
169 |             <div id="storagePopupMasterParent" class="storageList">
170 |                 <div id="storagePopupMasterContainer"/>
171 |             </div>
172 |             <div class="button_rack">
173 |                 <button id="local_storage_popup_close_button" class="center">Close Storage Popup</button>
174 |             </div>
175 |         </div>
176 |         <div class="window" id="freeze_listing">
177 |             <div id="freezeListingMasterContainer" class="storageList">
178 |                 <div id="freezeListingMasterContainerSub"/>
179 |             </div>
180 |             <div class="button_rack">
181 |                 <button id="freeze_list_refresh_button" class="left">Refresh List</button>
182 |                 <button id="freeze_list_close_button" class="right">Close Freeze State List</button>
183 |             </div>
184 |         </div>
185 |         <ul class="menu" id="GameBoy_file_popup">
186 |             <li>Open As<ul class="menu">
187 |                 <li id="data_uri_clicker">Base 64 Encoding</li>
188 |                 <li id="internal_file_clicker">Local File</li>
189 |             </ul></li>
190 |             <li id="save_SRAM_state_clicker">Save Game Memory</li>
191 |             <li id="save_state_clicker">Save Freeze State</li>
192 |             <li id="set_volume">Set Volume</li>
193 |             <li id="set_speed">Set Speed</li>
194 |             <li id="restart_cpu_clicker">Restart</li>
195 |             <li id="run_cpu_clicker">Resume</li>
196 |             <li id="kill_cpu_clicker">Pause</li>
197 |         </ul>
198 |         <ul class="menu" id="GameBoy_view_popup">
199 |             <li id="view_terminal">Terminal</li>
200 |             <li id="view_instructions">Instructions</li>
201 |             <li id="view_importer">Save Importer</li>
202 |             <li id="local_storage_list_menu">Save Manager</li>
203 |             <li id="freeze_list_menu">Freeze State Manager</li>
204 |             <li id="view_fullscreen">Fullscreen Mode</li>
205 |         </ul>
206 |         <div id="fullscreenContainer">
207 |             <canvas id="fullscreen" class="maximum"/>
208 |         </div>
209 |     </body>
210 | </html>


--------------------------------------------------------------------------------
/js/GameBoyIO.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var gameboy = null;						//GameBoyCore object.
  3 | var gbRunInterval = null;				//GameBoyCore Timer
  4 | var settings = [						//Some settings.
  5 | 	true, 								//Turn on sound.
  6 | 	true,								//Boot with boot ROM first?
  7 | 	false,								//Give priority to GameBoy mode
  8 | 	1,									//Volume level set.
  9 | 	true,								//Colorize GB mode?
 10 | 	false,								//Disallow typed arrays?
 11 | 	8,									//Interval for the emulator loop.
 12 | 	10,									//Audio buffer minimum span amount over x interpreter iterations.
 13 | 	20,									//Audio buffer maximum span amount over x interpreter iterations.
 14 | 	false,								//Override to allow for MBC1 instead of ROM only (compatibility for broken 3rd-party cartridges).
 15 | 	false,								//Override MBC RAM disabling and always allow reading and writing to the banks.
 16 | 	false,								//Use the GameBoy boot ROM instead of the GameBoy Color boot ROM.
 17 | 	false,								//Scale the canvas in JS, or let the browser scale the canvas?
 18 | 	true,								//Use image smoothing based scaling?
 19 |     [true, true, true, true]            //User controlled channel enables.
 20 | ];
 21 | function start(canvas, ROM) {
 22 | 	clearLastEmulation();
 23 | 	autoSave();	//If we are about to load a new game, then save the last one...
 24 | 	gameboy = new GameBoyCore(canvas, ROM);
 25 | 	gameboy.openMBC = openSRAM;
 26 | 	gameboy.openRTC = openRTC;
 27 | 	gameboy.start();
 28 | 	run();
 29 | }
 30 | function run() {
 31 | 	if (GameBoyEmulatorInitialized()) {
 32 | 		if (!GameBoyEmulatorPlaying()) {
 33 | 			gameboy.stopEmulator &= 1;
 34 | 			cout("Starting the iterator.", 0);
 35 | 			var dateObj = new Date();
 36 | 			gameboy.firstIteration = dateObj.getTime();
 37 | 			gameboy.iterations = 0;
 38 | 			gbRunInterval = setInterval(function () {
 39 | 				if (!document.hidden && !document.msHidden && !document.mozHidden && !document.webkitHidden) {
 40 | 					gameboy.run();
 41 | 				}
 42 | 			}, settings[6]);
 43 | 		}
 44 | 		else {
 45 | 			cout("The GameBoy core is already running.", 1);
 46 | 		}
 47 | 	}
 48 | 	else {
 49 | 		cout("GameBoy core cannot run while it has not been initialized.", 1);
 50 | 	}
 51 | }
 52 | function pause() {
 53 | 	if (GameBoyEmulatorInitialized()) {
 54 | 		if (GameBoyEmulatorPlaying()) {
 55 | 			autoSave();
 56 | 			clearLastEmulation();
 57 | 		}
 58 | 		else {
 59 | 			cout("GameBoy core has already been paused.", 1);
 60 | 		}
 61 | 	}
 62 | 	else {
 63 | 		cout("GameBoy core cannot be paused while it has not been initialized.", 1);
 64 | 	}
 65 | }
 66 | function clearLastEmulation() {
 67 | 	if (GameBoyEmulatorInitialized() && GameBoyEmulatorPlaying()) {
 68 | 		clearInterval(gbRunInterval);
 69 | 		gameboy.stopEmulator |= 2;
 70 | 		cout("The previous emulation has been cleared.", 0);
 71 | 	}
 72 | 	else {
 73 | 		cout("No previous emulation was found to be cleared.", 0);
 74 | 	}
 75 | }
 76 | function save() {
 77 | 	if (GameBoyEmulatorInitialized()) {
 78 | 		var state_suffix = 0;
 79 | 		while (findValue("FREEZE_" + gameboy.name + "_" + state_suffix) != null) {
 80 | 			state_suffix++;
 81 | 		}
 82 | 		saveState("FREEZE_" + gameboy.name + "_" + state_suffix);
 83 | 	}
 84 | 	else {
 85 | 		cout("GameBoy core cannot be saved while it has not been initialized.", 1);
 86 | 	}
 87 | }
 88 | function saveSRAM() {
 89 | 	if (GameBoyEmulatorInitialized()) {
 90 | 		if (gameboy.cBATT) {
 91 | 			try {
 92 | 				var sram = gameboy.saveSRAMState();
 93 | 				if (sram.length > 0) {
 94 | 					cout("Saving the SRAM...", 0);
 95 | 					if (findValue("SRAM_" + gameboy.name) != null) {
 96 | 						//Remove the outdated storage format save:
 97 | 						cout("Deleting the old SRAM save due to outdated format.", 0);
 98 | 						deleteValue("SRAM_" + gameboy.name);
 99 | 					}
100 | 					setValue("B64_SRAM_" + gameboy.name, arrayToBase64(sram));
101 | 				}
102 | 				else {
103 | 					cout("SRAM could not be saved because it was empty.", 1);
104 | 				}
105 | 			}
106 | 			catch (error) {
107 | 				cout("Could not save the current emulation state(\"" + error.message + "\").", 2);
108 | 			}
109 | 		}
110 | 		else {
111 | 			cout("Cannot save a game that does not have battery backed SRAM specified.", 1);
112 | 		}
113 | 		saveRTC();
114 | 	}
115 | 	else {
116 | 		cout("GameBoy core cannot be saved while it has not been initialized.", 1);
117 | 	}
118 | }
119 | function saveRTC() {	//Execute this when SRAM is being saved as well.
120 | 	if (GameBoyEmulatorInitialized()) {
121 | 		if (gameboy.cTIMER) {
122 | 			try {
123 | 				cout("Saving the RTC...", 0);
124 | 				setValue("RTC_" + gameboy.name, gameboy.saveRTCState());
125 | 			}
126 | 			catch (error) {
127 | 				cout("Could not save the RTC of the current emulation state(\"" + error.message + "\").", 2);
128 | 			}
129 | 		}
130 | 	}
131 | 	else {
132 | 		cout("GameBoy core cannot be saved while it has not been initialized.", 1);
133 | 	}
134 | }
135 | function autoSave() {
136 | 	if (GameBoyEmulatorInitialized()) {
137 | 		cout("Automatically saving the SRAM.", 0);
138 | 		saveSRAM();
139 | 		saveRTC();
140 | 	}
141 | }
142 | function openSRAM(filename) {
143 | 	try {
144 | 		if (findValue("B64_SRAM_" + filename) != null) {
145 | 			cout("Found a previous SRAM state (Will attempt to load).", 0);
146 | 			return base64ToArray(findValue("B64_SRAM_" + filename));
147 | 		}
148 | 		else if (findValue("SRAM_" + filename) != null) {
149 | 			cout("Found a previous SRAM state (Will attempt to load).", 0);
150 | 			return findValue("SRAM_" + filename);
151 | 		}
152 | 		else {
153 | 			cout("Could not find any previous SRAM copy for the current ROM.", 0);
154 | 		}
155 | 	}
156 | 	catch (error) {
157 | 		cout("Could not open the  SRAM of the saved emulation state.", 2);
158 | 	}
159 | 	return [];
160 | }
161 | function openRTC(filename) {
162 | 	try {
163 | 		if (findValue("RTC_" + filename) != null) {
164 | 			cout("Found a previous RTC state (Will attempt to load).", 0);
165 | 			return findValue("RTC_" + filename);
166 | 		}
167 | 		else {
168 | 			cout("Could not find any previous RTC copy for the current ROM.", 0);
169 | 		}
170 | 	}
171 | 	catch (error) {
172 | 		cout("Could not open the RTC data of the saved emulation state.", 2);
173 | 	}
174 | 	return [];
175 | }
176 | function saveState(filename) {
177 | 	if (GameBoyEmulatorInitialized()) {
178 | 		try {
179 | 			setValue(filename, gameboy.saveState());
180 | 			cout("Saved the current state as: " + filename, 0);
181 | 		}
182 | 		catch (error) {
183 | 			cout("Could not save the current emulation state(\"" + error.message + "\").", 2);
184 | 		}
185 | 	}
186 | 	else {
187 | 		cout("GameBoy core cannot be saved while it has not been initialized.", 1);
188 | 	}
189 | }
190 | function openState(filename, canvas) {
191 | 	try {
192 | 		if (findValue(filename) != null) {
193 | 			try {
194 | 				clearLastEmulation();
195 | 				cout("Attempting to run a saved emulation state.", 0);
196 | 				gameboy = new GameBoyCore(canvas, "");
197 | 				gameboy.savedStateFileName = filename;
198 | 				gameboy.returnFromState(findValue(filename));
199 | 				run();
200 | 			}
201 | 			catch (error) {
202 | 				alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
203 | 			}
204 | 		}
205 | 		else {
206 | 			cout("Could not find the save state " + filename + "\".", 2);
207 | 		}
208 | 	}
209 | 	catch (error) {
210 | 		cout("Could not open the saved emulation state.", 2);
211 | 	}
212 | }
213 | function import_save(blobData) {
214 | 	blobData = decodeBlob(blobData);
215 | 	if (blobData && blobData.blobs) {
216 | 		if (blobData.blobs.length > 0) {
217 | 			for (var index = 0; index < blobData.blobs.length; ++index) {
218 | 				cout("Importing blob \"" + blobData.blobs[index].blobID + "\"", 0);
219 | 				if (blobData.blobs[index].blobContent) {
220 | 					if (blobData.blobs[index].blobID.substring(0, 5) == "SRAM_") {
221 | 						setValue("B64_" + blobData.blobs[index].blobID, base64(blobData.blobs[index].blobContent));
222 | 					}
223 | 					else {
224 | 						setValue(blobData.blobs[index].blobID, JSON.parse(blobData.blobs[index].blobContent));
225 | 					}
226 | 				}
227 | 				else if (blobData.blobs[index].blobID) {
228 | 					cout("Save file imported had blob \"" + blobData.blobs[index].blobID + "\" with no blob data interpretable.", 2);
229 | 				}
230 | 				else {
231 | 					cout("Blob chunk information missing completely.", 2);
232 | 				}
233 | 			}
234 | 		}
235 | 		else {
236 | 			cout("Could not decode the imported file.", 2);
237 | 		}
238 | 	}
239 | 	else {
240 | 		cout("Could not decode the imported file.", 2);
241 | 	}
242 | }
243 | function generateBlob(keyName, encodedData) {
244 | 	//Append the file format prefix:
245 | 	var saveString = "EMULATOR_DATA";
246 | 	var consoleID = "GameBoy";
247 | 	//Figure out the length:
248 | 	var totalLength = (saveString.length + 4 + (1 + consoleID.length)) + ((1 + keyName.length) + (4 + encodedData.length));
249 | 	//Append the total length in bytes:
250 | 	saveString += to_little_endian_dword(totalLength);
251 | 	//Append the console ID text's length:
252 | 	saveString += to_byte(consoleID.length);
253 | 	//Append the console ID text:
254 | 	saveString += consoleID;
255 | 	//Append the blob ID:
256 | 	saveString += to_byte(keyName.length);
257 | 	saveString += keyName;
258 | 	//Now append the save data:
259 | 	saveString += to_little_endian_dword(encodedData.length);
260 | 	saveString += encodedData;
261 | 	return saveString;
262 | }
263 | function generateMultiBlob(blobPairs) {
264 | 	var consoleID = "GameBoy";
265 | 	//Figure out the initial length:
266 | 	var totalLength = 13 + 4 + 1 + consoleID.length;
267 | 	//Append the console ID text's length:
268 | 	var saveString = to_byte(consoleID.length);
269 | 	//Append the console ID text:
270 | 	saveString += consoleID;
271 | 	var keyName = "";
272 | 	var encodedData = "";
273 | 	//Now append all the blobs:
274 | 	for (var index = 0; index < blobPairs.length; ++index) {
275 | 		keyName = blobPairs[index][0];
276 | 		encodedData = blobPairs[index][1];
277 | 		//Append the blob ID:
278 | 		saveString += to_byte(keyName.length);
279 | 		saveString += keyName;
280 | 		//Now append the save data:
281 | 		saveString += to_little_endian_dword(encodedData.length);
282 | 		saveString += encodedData;
283 | 		//Update the total length:
284 | 		totalLength += 1 + keyName.length + 4 + encodedData.length;
285 | 	}
286 | 	//Now add the prefix:
287 | 	saveString = "EMULATOR_DATA" + to_little_endian_dword(totalLength) + saveString;
288 | 	return saveString;
289 | }
290 | function decodeBlob(blobData) {
291 | 	/*Format is as follows:
292 | 		- 13 byte string "EMULATOR_DATA"
293 | 		- 4 byte total size (including these 4 bytes).
294 | 		- 1 byte Console type ID length
295 | 		- Console type ID text of 8 bit size
296 | 		blobs {
297 | 			- 1 byte blob ID length
298 | 			- blob ID text (Used to say what the data is (SRAM/freeze state/etc...))
299 | 			- 4 byte blob length
300 | 			- blob length of 32 bit size
301 | 		}
302 | 	*/
303 | 	var length = blobData.length;
304 | 	var blobProperties = {};
305 | 	blobProperties.consoleID = null;
306 | 	var blobsCount = -1;
307 | 	blobProperties.blobs = [];
308 | 	if (length > 17) {
309 | 		if (blobData.substring(0, 13) == "EMULATOR_DATA") {
310 | 			var length = Math.min(((blobData.charCodeAt(16) & 0xFF) << 24) | ((blobData.charCodeAt(15) & 0xFF) << 16) | ((blobData.charCodeAt(14) & 0xFF) << 8) | (blobData.charCodeAt(13) & 0xFF), length);
311 | 			var consoleIDLength = blobData.charCodeAt(17) & 0xFF;
312 | 			if (length > 17 + consoleIDLength) {
313 | 				blobProperties.consoleID = blobData.substring(18, 18 + consoleIDLength);
314 | 				var blobIDLength = 0;
315 | 				var blobLength = 0;
316 | 				for (var index = 18 + consoleIDLength; index < length;) {
317 | 					blobIDLength = blobData.charCodeAt(index++) & 0xFF;
318 | 					if (index + blobIDLength < length) {
319 | 						blobProperties.blobs[++blobsCount] = {};
320 | 						blobProperties.blobs[blobsCount].blobID = blobData.substring(index, index + blobIDLength);
321 | 						index += blobIDLength;
322 | 						if (index + 4 < length) {
323 | 							blobLength = ((blobData.charCodeAt(index + 3) & 0xFF) << 24) | ((blobData.charCodeAt(index + 2) & 0xFF) << 16) | ((blobData.charCodeAt(index + 1) & 0xFF) << 8) | (blobData.charCodeAt(index) & 0xFF);
324 | 							index += 4;
325 | 							if (index + blobLength <= length) {
326 | 								blobProperties.blobs[blobsCount].blobContent =  blobData.substring(index, index + blobLength);
327 | 								index += blobLength;
328 | 							}
329 | 							else {
330 | 								cout("Blob length check failed, blob determined to be incomplete.", 2);
331 | 								break;
332 | 							}
333 | 						}
334 | 						else {
335 | 							cout("Blob was incomplete, bailing out.", 2);
336 | 							break;
337 | 						}
338 | 					}
339 | 					else {
340 | 						cout("Blob was incomplete, bailing out.", 2);
341 | 						break;
342 | 					}
343 | 				}
344 | 			}
345 | 		}
346 | 	}
347 | 	return blobProperties;
348 | }
349 | function matchKey(key) {	//Maps a keyboard key to a gameboy key.
350 | 	//Order: Right, Left, Up, Down, A, B, Select, Start
351 | 	var keymap = ["right", "left", "up", "down", "a", "b", "select", "start"];	//Keyboard button map.
352 | 	for (var index = 0; index < keymap.length; index++) {
353 | 		if (keymap[index] == key) {
354 | 			return index;
355 | 		}
356 | 	}
357 | 	return -1;
358 | }
359 | function GameBoyEmulatorInitialized() {
360 | 	return (typeof gameboy == "object" && gameboy != null);
361 | }
362 | function GameBoyEmulatorPlaying() {
363 | 	return ((gameboy.stopEmulator & 2) == 0);
364 | }
365 | function GameBoyKeyDown(key) {
366 | 	if (GameBoyEmulatorInitialized() && GameBoyEmulatorPlaying()) {
367 | 		GameBoyJoyPadEvent(matchKey(key), true);
368 | 	}
369 | }
370 | function GameBoyJoyPadEvent(keycode, down) {
371 | 	if (GameBoyEmulatorInitialized() && GameBoyEmulatorPlaying()) {
372 | 		if (keycode >= 0 && keycode < 8) {
373 | 			gameboy.JoyPadEvent(keycode, down);
374 | 		}
375 | 	}
376 | }
377 | function GameBoyKeyUp(key) {
378 | 	if (GameBoyEmulatorInitialized() && GameBoyEmulatorPlaying()) {
379 | 		GameBoyJoyPadEvent(matchKey(key), false);
380 | 	}
381 | }
382 | function GameBoyGyroSignalHandler(e) {
383 | 	if (GameBoyEmulatorInitialized() && GameBoyEmulatorPlaying()) {
384 | 		if (e.gamma || e.beta) {
385 | 			gameboy.GyroEvent(e.gamma * Math.PI / 180, e.beta * Math.PI / 180);
386 | 		}
387 | 		else {
388 | 			gameboy.GyroEvent(e.x, e.y);
389 | 		}
390 | 		try {
391 | 			e.preventDefault();
392 | 		}
393 | 		catch (error) { }
394 | 	}
395 | }
396 | //The emulator will call this to sort out the canvas properties for (re)initialization.
397 | function initNewCanvas() {
398 | 	if (GameBoyEmulatorInitialized()) {
399 | 		gameboy.canvas.width = gameboy.canvas.clientWidth;
400 | 		gameboy.canvas.height = gameboy.canvas.clientHeight;
401 | 	}
402 | }
403 | //Call this when resizing the canvas:
404 | function initNewCanvasSize() {
405 | 	if (GameBoyEmulatorInitialized()) {
406 | 		if (!settings[12]) {
407 | 			if (gameboy.onscreenWidth != 160 || gameboy.onscreenHeight != 144) {
408 | 				gameboy.initLCD();
409 | 			}
410 | 		}
411 | 		else {
412 | 			if (gameboy.onscreenWidth != gameboy.canvas.clientWidth || gameboy.onscreenHeight != gameboy.canvas.clientHeight) {
413 | 				gameboy.initLCD();
414 | 			}
415 | 		}
416 | 	}
417 | }
418 | 


--------------------------------------------------------------------------------
/js/other/XAudioJS.swf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/taisel/GameBoy-Online/47f9f638a8a9445aaa75050f634e437baa34aae0/js/other/XAudioJS.swf


--------------------------------------------------------------------------------
/js/other/XAudioServer.js:
--------------------------------------------------------------------------------
  1 | //2010-2013 Grant Galitz - XAudioJS realtime audio output compatibility library:
  2 | var XAudioJSscriptsHandle = document.getElementsByTagName("script");
  3 | var XAudioJSsourceHandle = XAudioJSscriptsHandle[XAudioJSscriptsHandle.length-1].src;
  4 | function XAudioServer(channels, sampleRate, minBufferSize, maxBufferSize, underRunCallback, volume, failureCallback) {
  5 | 	XAudioJSChannelsAllocated = Math.max(channels, 1);
  6 | 	this.XAudioJSSampleRate = Math.abs(sampleRate);
  7 | 	XAudioJSMinBufferSize = (minBufferSize >= (XAudioJSSamplesPerCallback * XAudioJSChannelsAllocated) && minBufferSize < maxBufferSize) ? (minBufferSize & (-XAudioJSChannelsAllocated)) : (XAudioJSSamplesPerCallback * XAudioJSChannelsAllocated);
  8 | 	XAudioJSMaxBufferSize = (Math.floor(maxBufferSize) > XAudioJSMinBufferSize + XAudioJSChannelsAllocated) ? (maxBufferSize & (-XAudioJSChannelsAllocated)) : (XAudioJSMinBufferSize * XAudioJSChannelsAllocated);
  9 | 	this.underRunCallback = (typeof underRunCallback == "function") ? underRunCallback : function () {};
 10 | 	XAudioJSVolume = (volume >= 0 && volume <= 1) ? volume : 1;
 11 | 	this.failureCallback = (typeof failureCallback == "function") ? failureCallback : function () { throw(new Error("XAudioJS has encountered a fatal error.")); };
 12 | 	this.initializeAudio();
 13 | }
 14 | XAudioServer.prototype.MOZWriteAudioNoCallback = function (buffer) {
 15 |     //Resample before passing to the moz audio api:
 16 |     var bufferLength  = buffer.length;
 17 |     for (var bufferIndex = 0; bufferIndex < bufferLength;) {
 18 |         var sliceLength = Math.min(bufferLength - bufferIndex, XAudioJSMaxBufferSize);
 19 |         for (var sliceIndex = 0; sliceIndex < sliceLength; ++sliceIndex) {
 20 |             XAudioJSAudioContextSampleBuffer[sliceIndex] = buffer[bufferIndex++];
 21 |         }
 22 |         var resampleLength = XAudioJSResampleControl.resampler(XAudioJSGetArraySlice(XAudioJSAudioContextSampleBuffer, sliceIndex));
 23 |         if (resampleLength > 0) {
 24 |             var resampledResult = XAudioJSResampleControl.outputBuffer;
 25 |             var resampledBuffer = XAudioJSGetArraySlice(resampledResult, resampleLength);
 26 |             this.samplesAlreadyWritten += this.audioHandleMoz.mozWriteAudio(resampledBuffer);
 27 |         }
 28 |     }
 29 | }
 30 | XAudioServer.prototype.callbackBasedWriteAudioNoCallback = function (buffer) {
 31 | 	//Callback-centered audio APIs:
 32 | 	var length = buffer.length;
 33 | 	for (var bufferCounter = 0; bufferCounter < length && XAudioJSAudioBufferSize < XAudioJSMaxBufferSize;) {
 34 | 		XAudioJSAudioContextSampleBuffer[XAudioJSAudioBufferSize++] = buffer[bufferCounter++];
 35 | 	}
 36 | }
 37 | /*Pass your samples into here!
 38 | Pack your samples as a one-dimenional array
 39 | With the channel samples packed uniformly.
 40 | examples:
 41 |     mono - [left, left, left, left]
 42 |     stereo - [left, right, left, right, left, right, left, right]
 43 | */
 44 | XAudioServer.prototype.writeAudio = function (buffer) {
 45 | 	switch (this.audioType) {
 46 | 		case 0:
 47 | 			this.MOZWriteAudioNoCallback(buffer);
 48 | 			this.MOZExecuteCallback();
 49 | 			break;
 50 | 		case 2:
 51 | 			this.checkFlashInit();
 52 | 		case 1:
 53 | 		case 3:
 54 | 			this.callbackBasedWriteAudioNoCallback(buffer);
 55 | 			this.callbackBasedExecuteCallback();
 56 | 			break;
 57 | 		default:
 58 | 			this.failureCallback();
 59 | 	}
 60 | }
 61 | /*Pass your samples into here if you don't want automatic callback calling:
 62 | Pack your samples as a one-dimenional array
 63 | With the channel samples packed uniformly.
 64 | examples:
 65 |     mono - [left, left, left, left]
 66 |     stereo - [left, right, left, right, left, right, left, right]
 67 | Useful in preventing infinite recursion issues with calling writeAudio inside your callback.
 68 | */
 69 | XAudioServer.prototype.writeAudioNoCallback = function (buffer) {
 70 | 	switch (this.audioType) {
 71 | 		case 0:
 72 | 			this.MOZWriteAudioNoCallback(buffer);
 73 | 			break;
 74 | 		case 2:
 75 | 			this.checkFlashInit();
 76 | 		case 1:
 77 | 		case 3:
 78 | 			this.callbackBasedWriteAudioNoCallback(buffer);
 79 | 			break;
 80 | 		default:
 81 | 			this.failureCallback();
 82 | 	}
 83 | }
 84 | //Developer can use this to see how many samples to write (example: minimum buffer allotment minus remaining samples left returned from this function to make sure maximum buffering is done...)
 85 | //If null is returned, then that means metric could not be done.
 86 | XAudioServer.prototype.remainingBuffer = function () {
 87 | 	switch (this.audioType) {
 88 | 		case 0:
 89 | 			return Math.floor((this.samplesAlreadyWritten - this.audioHandleMoz.mozCurrentSampleOffset()) * XAudioJSResampleControl.ratioWeight / XAudioJSChannelsAllocated) * XAudioJSChannelsAllocated;
 90 | 		case 2:
 91 | 			this.checkFlashInit();
 92 | 		case 1:
 93 | 		case 3:
 94 | 			return (Math.floor((XAudioJSResampledSamplesLeft() * XAudioJSResampleControl.ratioWeight) / XAudioJSChannelsAllocated) * XAudioJSChannelsAllocated) + XAudioJSAudioBufferSize;
 95 | 		default:
 96 | 			this.failureCallback();
 97 | 			return null;
 98 | 	}
 99 | }
100 | XAudioServer.prototype.MOZExecuteCallback = function () {
101 | 	//mozAudio:
102 | 	var samplesRequested = XAudioJSMinBufferSize - this.remainingBuffer();
103 | 	if (samplesRequested > 0) {
104 | 		this.MOZWriteAudioNoCallback(this.underRunCallback(samplesRequested));
105 | 	}
106 | }
107 | XAudioServer.prototype.callbackBasedExecuteCallback = function () {
108 | 	//WebKit /Flash Audio:
109 | 	var samplesRequested = XAudioJSMinBufferSize - this.remainingBuffer();
110 | 	if (samplesRequested > 0) {
111 | 		this.callbackBasedWriteAudioNoCallback(this.underRunCallback(samplesRequested));
112 | 	}
113 | }
114 | //If you just want your callback called for any possible refill (Execution of callback is still conditional):
115 | XAudioServer.prototype.executeCallback = function () {
116 | 	switch (this.audioType) {
117 | 		case 0:
118 | 			this.MOZExecuteCallback();
119 | 			break;
120 | 		case 2:
121 | 			this.checkFlashInit();
122 | 		case 1:
123 | 		case 3:
124 | 			this.callbackBasedExecuteCallback();
125 | 			break;
126 | 		default:
127 | 			this.failureCallback();
128 | 	}
129 | }
130 | //DO NOT CALL THIS, the lib calls this internally!
131 | XAudioServer.prototype.initializeAudio = function () {
132 |     try {
133 |         this.initializeMozAudio();
134 |     }
135 |     catch (error) {
136 |         try {
137 |             this.initializeWebAudio();
138 |         }
139 |         catch (error) {
140 |             try {
141 |                 this.initializeMediaStream();
142 |             }
143 |             catch (error) {
144 |                 try {
145 |                     this.initializeFlashAudio();
146 |                 }
147 |                 catch (error) {
148 |                     this.audioType = -1;
149 |                     this.failureCallback();
150 |                 }
151 |             }
152 |         }
153 |     }
154 | }
155 | XAudioServer.prototype.initializeMediaStream = function () {
156 | 	this.audioHandleMediaStream = new Audio();
157 | 	this.resetCallbackAPIAudioBuffer(XAudioJSMediaStreamSampleRate);
158 | 	if (XAudioJSMediaStreamWorker) {
159 | 		//WebWorker is not GC'd, so manually collect it:
160 | 		XAudioJSMediaStreamWorker.terminate();
161 | 	}
162 | 	XAudioJSMediaStreamWorker = new Worker(XAudioJSsourceHandle.substring(0, XAudioJSsourceHandle.length - 3) + "MediaStreamWorker.js");
163 | 	this.audioHandleMediaStreamProcessing = new ProcessedMediaStream(XAudioJSMediaStreamWorker, XAudioJSMediaStreamSampleRate, XAudioJSChannelsAllocated);
164 | 	this.audioHandleMediaStream.src = this.audioHandleMediaStreamProcessing;
165 | 	this.audioHandleMediaStream.volume = XAudioJSVolume;
166 | 	XAudioJSMediaStreamWorker.onmessage = XAudioJSMediaStreamPushAudio;
167 | 	XAudioJSMediaStreamWorker.postMessage([1, XAudioJSResampleBufferSize, XAudioJSChannelsAllocated]);
168 | 	this.audioHandleMediaStream.play();
169 | 	this.audioType = 3;
170 | }
171 | XAudioServer.prototype.initializeMozAudio = function () {
172 |     this.audioHandleMoz = new Audio();
173 | 	this.audioHandleMoz.mozSetup(XAudioJSChannelsAllocated, XAudioJSMozAudioSampleRate);
174 | 	this.audioHandleMoz.volume = XAudioJSVolume;
175 | 	this.samplesAlreadyWritten = 0;
176 | 	this.audioType = 0;
177 | 	//if (navigator.platform != "MacIntel" && navigator.platform != "MacPPC") {
178 | 		//Add some additional buffering space to workaround a moz audio api issue:
179 | 		var bufferAmount = (this.XAudioJSSampleRate * XAudioJSChannelsAllocated / 10) | 0;
180 | 		bufferAmount -= bufferAmount % XAudioJSChannelsAllocated;
181 | 		this.samplesAlreadyWritten -= bufferAmount;
182 | 	//}
183 |     this.initializeResampler(XAudioJSMozAudioSampleRate);
184 | }
185 | XAudioServer.prototype.initializeWebAudio = function () {
186 | 	if (!XAudioJSWebAudioLaunchedContext) {
187 |         try {
188 |             XAudioJSWebAudioContextHandle = new AudioContext();								//Create a system audio context.
189 |         }
190 |         catch (error) {
191 |             XAudioJSWebAudioContextHandle = new webkitAudioContext();							//Create a system audio context.
192 |         }
193 |         XAudioJSWebAudioLaunchedContext = true;
194 |     }
195 |     if (XAudioJSWebAudioAudioNode) {
196 |         XAudioJSWebAudioAudioNode.disconnect();
197 |         XAudioJSWebAudioAudioNode.onaudioprocess = null;
198 |         XAudioJSWebAudioAudioNode = null;
199 |     }
200 |     try {
201 |         XAudioJSWebAudioAudioNode = XAudioJSWebAudioContextHandle.createScriptProcessor(XAudioJSSamplesPerCallback, 0, XAudioJSChannelsAllocated);	//Create the js event node.
202 |     }
203 |     catch (error) {
204 |         XAudioJSWebAudioAudioNode = XAudioJSWebAudioContextHandle.createJavaScriptNode(XAudioJSSamplesPerCallback, 0, XAudioJSChannelsAllocated);	//Create the js event node.
205 |     }
206 |     XAudioJSWebAudioAudioNode.onaudioprocess = XAudioJSWebAudioEvent;																			//Connect the audio processing event to a handling function so we can manipulate output
207 |     XAudioJSWebAudioAudioNode.connect(XAudioJSWebAudioContextHandle.destination);																//Send and chain the output of the audio manipulation to the system audio output.
208 |     this.resetCallbackAPIAudioBuffer(XAudioJSWebAudioContextHandle.sampleRate);
209 |     this.audioType = 1;
210 |     /*
211 |      Firefox has a bug in its web audio implementation...
212 |      The node may randomly stop playing on Mac OS X for no
213 |      good reason. Keep a watchdog timer to restart the failed
214 |      node if it glitches. Google Chrome never had this issue.
215 |      */
216 |     XAudioJSWebAudioWatchDogLast = (new Date()).getTime();
217 |     if (navigator.userAgent.indexOf('Gecko/') > -1) {
218 |         if (XAudioJSWebAudioWatchDogTimer) {
219 |             clearInterval(XAudioJSWebAudioWatchDogTimer);
220 |         }
221 |         var parentObj = this;
222 |         XAudioJSWebAudioWatchDogTimer = setInterval(function () {
223 |             var timeDiff = (new Date()).getTime() - XAudioJSWebAudioWatchDogLast;
224 |             if (timeDiff > 500) {
225 |                 parentObj.initializeWebAudio();
226 |             }
227 |         }, 500);
228 |     }
229 | }
230 | XAudioServer.prototype.initializeFlashAudio = function () {
231 | 	var existingFlashload = document.getElementById("XAudioJS");
232 | 	this.flashInitialized = false;
233 | 	this.resetCallbackAPIAudioBuffer(44100);
234 | 	switch (XAudioJSChannelsAllocated) {
235 | 		case 1:
236 | 			XAudioJSFlashTransportEncoder = XAudioJSGenerateFlashMonoString;
237 | 			break;
238 | 		case 2:
239 | 			XAudioJSFlashTransportEncoder = XAudioJSGenerateFlashStereoString;
240 | 			break;
241 | 		default:
242 | 			XAudioJSFlashTransportEncoder = XAudioJSGenerateFlashSurroundString;
243 | 	}
244 | 	if (existingFlashload == null) {
245 | 		this.audioHandleFlash = null;
246 | 		var thisObj = this;
247 | 		var mainContainerNode = document.createElement("div");
248 | 		mainContainerNode.setAttribute("style", "position: fixed; bottom: 0px; right: 0px; margin: 0px; padding: 0px; border: none; width: 8px; height: 8px; overflow: hidden; z-index: -1000; ");
249 | 		var containerNode = document.createElement("div");
250 | 		containerNode.setAttribute("style", "position: static; border: none; width: 0px; height: 0px; visibility: hidden; margin: 8px; padding: 0px;");
251 | 		containerNode.setAttribute("id", "XAudioJS");
252 | 		mainContainerNode.appendChild(containerNode);
253 | 		document.getElementsByTagName("body")[0].appendChild(mainContainerNode);
254 | 		swfobject.embedSWF(
255 | 			XAudioJSsourceHandle.substring(0, XAudioJSsourceHandle.length - 9) + "JS.swf",
256 | 			"XAudioJS",
257 | 			"8",
258 | 			"8",
259 | 			"9.0.0",
260 | 			"",
261 | 			{},
262 | 			{"allowscriptaccess":"always"},
263 | 			{"style":"position: static; visibility: hidden; margin: 8px; padding: 0px; border: none"},
264 | 			function (event) {
265 | 				if (event.success) {
266 | 					thisObj.audioHandleFlash = event.ref;
267 | 					thisObj.checkFlashInit();
268 | 				}
269 | 				else {
270 | 					thisObj.failureCallback();
271 | 					thisObj.audioType = -1;
272 | 				}
273 | 			}
274 | 		);
275 | 	}
276 | 	else {
277 | 		this.audioHandleFlash = existingFlashload;
278 | 		this.checkFlashInit();
279 | 	}
280 | 	this.audioType = 2;
281 | }
282 | XAudioServer.prototype.changeVolume = function (newVolume) {
283 | 	if (newVolume >= 0 && newVolume <= 1) {
284 | 		XAudioJSVolume = newVolume;
285 | 		switch (this.audioType) {
286 | 			case 0:
287 | 				this.audioHandleMoz.volume = XAudioJSVolume;
288 | 			case 1:
289 | 				break;
290 | 			case 2:
291 | 				if (this.flashInitialized) {
292 | 					this.audioHandleFlash.changeVolume(XAudioJSVolume);
293 | 				}
294 | 				else {
295 | 					this.checkFlashInit();
296 | 				}
297 | 				break;
298 | 			case 3:
299 | 				this.audioHandleMediaStream.volume = XAudioJSVolume;
300 | 				break;
301 | 			default:
302 | 				this.failureCallback();
303 | 		}
304 | 	}
305 | }
306 | //Checks to see if the NPAPI Adobe Flash bridge is ready yet:
307 | XAudioServer.prototype.checkFlashInit = function () {
308 | 	if (!this.flashInitialized) {
309 | 		try {
310 | 			if (this.audioHandleFlash && this.audioHandleFlash.initialize) {
311 | 				this.flashInitialized = true;
312 | 				this.audioHandleFlash.initialize(XAudioJSChannelsAllocated, XAudioJSVolume);
313 | 			}
314 | 		}
315 | 		catch (error) {
316 | 			this.flashInitialized = false;
317 | 		}
318 | 	}
319 | }
320 | //Set up the resampling:
321 | XAudioServer.prototype.resetCallbackAPIAudioBuffer = function (APISampleRate) {
322 | 	XAudioJSAudioBufferSize = XAudioJSResampleBufferEnd = XAudioJSResampleBufferStart = 0;
323 |     this.initializeResampler(APISampleRate);
324 |     XAudioJSResampledBuffer = this.getFloat32(XAudioJSResampleBufferSize);
325 | }
326 | XAudioServer.prototype.initializeResampler = function (sampleRate) {
327 |     XAudioJSAudioContextSampleBuffer = this.getFloat32(XAudioJSMaxBufferSize);
328 |     XAudioJSResampleBufferSize = Math.max(XAudioJSMaxBufferSize * Math.ceil(sampleRate / this.XAudioJSSampleRate) + XAudioJSChannelsAllocated, XAudioJSSamplesPerCallback * XAudioJSChannelsAllocated);
329 | 	XAudioJSResampleControl = new Resampler(this.XAudioJSSampleRate, sampleRate, XAudioJSChannelsAllocated, XAudioJSResampleBufferSize, true);
330 | }
331 | XAudioServer.prototype.getFloat32 = function (size) {
332 | 	try {
333 | 		return new Float32Array(size);
334 | 	}
335 | 	catch (error) {
336 | 		return [];
337 | 	}
338 | }
339 | function XAudioJSFlashAudioEvent() {		//The callback that flash calls...
340 | 	XAudioJSResampleRefill();
341 | 	return XAudioJSFlashTransportEncoder();
342 | }
343 | function XAudioJSGenerateFlashSurroundString() {	//Convert the arrays to one long string for speed.
344 | 	var XAudioJSTotalSamples = XAudioJSSamplesPerCallback << 1;
345 | 	if (XAudioJSBinaryString.length > XAudioJSTotalSamples) {
346 | 		XAudioJSBinaryString = [];
347 | 	}
348 | 	XAudioJSTotalSamples = 0;
349 | 	for (var index = 0; index < XAudioJSSamplesPerCallback && XAudioJSResampleBufferStart != XAudioJSResampleBufferEnd; ++index) {
350 | 		//Sanitize the buffer:
351 | 		XAudioJSBinaryString[XAudioJSTotalSamples++] = String.fromCharCode(((Math.min(Math.max(XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
352 | 		XAudioJSBinaryString[XAudioJSTotalSamples++] = String.fromCharCode(((Math.min(Math.max(XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
353 | 		XAudioJSResampleBufferStart += XAudioJSChannelsAllocated - 2;
354 | 		if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
355 | 			XAudioJSResampleBufferStart = 0;
356 | 		}
357 | 	}
358 | 	return XAudioJSBinaryString.join("");
359 | }
360 | function XAudioJSGenerateFlashStereoString() {	//Convert the arrays to one long string for speed.
361 | 	var XAudioJSTotalSamples = XAudioJSSamplesPerCallback << 1;
362 | 	if (XAudioJSBinaryString.length > XAudioJSTotalSamples) {
363 | 		XAudioJSBinaryString = [];
364 | 	}
365 | 	for (var index = 0; index < XAudioJSTotalSamples && XAudioJSResampleBufferStart != XAudioJSResampleBufferEnd;) {
366 | 		//Sanitize the buffer:
367 | 		XAudioJSBinaryString[index++] = String.fromCharCode(((Math.min(Math.max(XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
368 | 		XAudioJSBinaryString[index++] = String.fromCharCode(((Math.min(Math.max(XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
369 | 		if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
370 | 			XAudioJSResampleBufferStart = 0;
371 | 		}
372 | 	}
373 | 	return XAudioJSBinaryString.join("");
374 | }
375 | function XAudioJSGenerateFlashMonoString() {	//Convert the array to one long string for speed.
376 | 	if (XAudioJSBinaryString.length > XAudioJSSamplesPerCallback) {
377 | 		XAudioJSBinaryString = [];
378 | 	}
379 | 	for (var index = 0; index < XAudioJSSamplesPerCallback && XAudioJSResampleBufferStart != XAudioJSResampleBufferEnd;) {
380 | 		//Sanitize the buffer:
381 | 		XAudioJSBinaryString[index++] = String.fromCharCode(((Math.min(Math.max(XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
382 | 		if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
383 | 			XAudioJSResampleBufferStart = 0;
384 | 		}
385 | 	}
386 | 	return XAudioJSBinaryString.join("");
387 | }
388 | //Some Required Globals:
389 | var XAudioJSWebAudioContextHandle = null;
390 | var XAudioJSWebAudioAudioNode = null;
391 | var XAudioJSWebAudioWatchDogTimer = null;
392 | var XAudioJSWebAudioWatchDogLast = false;
393 | var XAudioJSWebAudioLaunchedContext = false;
394 | var XAudioJSAudioContextSampleBuffer = [];
395 | var XAudioJSResampledBuffer = [];
396 | var XAudioJSMinBufferSize = 15000;
397 | var XAudioJSMaxBufferSize = 25000;
398 | var XAudioJSChannelsAllocated = 1;
399 | var XAudioJSVolume = 1;
400 | var XAudioJSResampleControl = null;
401 | var XAudioJSAudioBufferSize = 0;
402 | var XAudioJSResampleBufferStart = 0;
403 | var XAudioJSResampleBufferEnd = 0;
404 | var XAudioJSResampleBufferSize = 0;
405 | var XAudioJSMediaStreamWorker = null;
406 | var XAudioJSMediaStreamBuffer = [];
407 | var XAudioJSMediaStreamSampleRate = 44100;
408 | var XAudioJSMozAudioSampleRate = 44100;
409 | var XAudioJSSamplesPerCallback = 2048;			//Has to be between 2048 and 4096 (If over, then samples are ignored, if under then silence is added).
410 | var XAudioJSFlashTransportEncoder = null;
411 | var XAudioJSMediaStreamLengthAliasCounter = 0;
412 | var XAudioJSBinaryString = [];
413 | function XAudioJSWebAudioEvent(event) {		//Web Audio API callback...
414 | 	if (XAudioJSWebAudioWatchDogTimer) {
415 | 		XAudioJSWebAudioWatchDogLast = (new Date()).getTime();
416 | 	}
417 | 	//Find all output channels:
418 | 	for (var bufferCount = 0, buffers = []; bufferCount < XAudioJSChannelsAllocated; ++bufferCount) {
419 | 		buffers[bufferCount] = event.outputBuffer.getChannelData(bufferCount);
420 | 	}
421 | 	//Make sure we have resampled samples ready:
422 | 	XAudioJSResampleRefill();
423 | 	//Copy samples from XAudioJS to the Web Audio API:
424 | 	for (var index = 0; index < XAudioJSSamplesPerCallback && XAudioJSResampleBufferStart != XAudioJSResampleBufferEnd; ++index) {
425 | 		for (bufferCount = 0; bufferCount < XAudioJSChannelsAllocated; ++bufferCount) {
426 | 			buffers[bufferCount][index] = XAudioJSResampledBuffer[XAudioJSResampleBufferStart++] * XAudioJSVolume;
427 | 		}
428 | 		if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
429 | 			XAudioJSResampleBufferStart = 0;
430 | 		}
431 | 	}
432 | 	//Pad with silence if we're underrunning:
433 | 	while (index < XAudioJSSamplesPerCallback) {
434 | 		for (bufferCount = 0; bufferCount < XAudioJSChannelsAllocated; ++bufferCount) {
435 | 			buffers[bufferCount][index] = 0;
436 | 		}
437 | 		++index;
438 | 	}
439 | }
440 | //MediaStream API buffer push
441 | function XAudioJSMediaStreamPushAudio(event) {
442 | 	var index = 0;
443 | 	var audioLengthRequested = event.data;
444 | 	var samplesPerCallbackAll = XAudioJSSamplesPerCallback * XAudioJSChannelsAllocated;
445 | 	var XAudioJSMediaStreamLengthAlias = audioLengthRequested % XAudioJSSamplesPerCallback;
446 | 	audioLengthRequested = audioLengthRequested - (XAudioJSMediaStreamLengthAliasCounter - (XAudioJSMediaStreamLengthAliasCounter % XAudioJSSamplesPerCallback)) - XAudioJSMediaStreamLengthAlias + XAudioJSSamplesPerCallback;
447 | 	XAudioJSMediaStreamLengthAliasCounter -= XAudioJSMediaStreamLengthAliasCounter - (XAudioJSMediaStreamLengthAliasCounter % XAudioJSSamplesPerCallback);
448 | 	XAudioJSMediaStreamLengthAliasCounter += XAudioJSSamplesPerCallback - XAudioJSMediaStreamLengthAlias;
449 | 	if (XAudioJSMediaStreamBuffer.length != samplesPerCallbackAll) {
450 | 		XAudioJSMediaStreamBuffer = new Float32Array(samplesPerCallbackAll);
451 | 	}
452 | 	XAudioJSResampleRefill();
453 | 	while (index < audioLengthRequested) {
454 | 		var index2 = 0;
455 | 		while (index2 < samplesPerCallbackAll && XAudioJSResampleBufferStart != XAudioJSResampleBufferEnd) {
456 | 			XAudioJSMediaStreamBuffer[index2++] = XAudioJSResampledBuffer[XAudioJSResampleBufferStart++];
457 | 			if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
458 | 				XAudioJSResampleBufferStart = 0;
459 | 			}
460 | 		}
461 | 		XAudioJSMediaStreamWorker.postMessage([0, XAudioJSMediaStreamBuffer]);
462 | 		index += XAudioJSSamplesPerCallback;
463 | 	}
464 | }
465 | function XAudioJSResampleRefill() {
466 | 	if (XAudioJSAudioBufferSize > 0) {
467 | 		//Resample a chunk of audio:
468 | 		var resampleLength = XAudioJSResampleControl.resampler(XAudioJSGetBufferSamples());
469 | 		var resampledResult = XAudioJSResampleControl.outputBuffer;
470 | 		for (var index2 = 0; index2 < resampleLength;) {
471 | 			XAudioJSResampledBuffer[XAudioJSResampleBufferEnd++] = resampledResult[index2++];
472 | 			if (XAudioJSResampleBufferEnd == XAudioJSResampleBufferSize) {
473 | 				XAudioJSResampleBufferEnd = 0;
474 | 			}
475 | 			if (XAudioJSResampleBufferStart == XAudioJSResampleBufferEnd) {
476 | 				XAudioJSResampleBufferStart += XAudioJSChannelsAllocated;
477 | 				if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
478 | 					XAudioJSResampleBufferStart = 0;
479 | 				}
480 | 			}
481 | 		}
482 | 		XAudioJSAudioBufferSize = 0;
483 | 	}
484 | }
485 | function XAudioJSResampledSamplesLeft() {
486 | 	return ((XAudioJSResampleBufferStart <= XAudioJSResampleBufferEnd) ? 0 : XAudioJSResampleBufferSize) + XAudioJSResampleBufferEnd - XAudioJSResampleBufferStart;
487 | }
488 | function XAudioJSGetBufferSamples() {
489 |     return XAudioJSGetArraySlice(XAudioJSAudioContextSampleBuffer, XAudioJSAudioBufferSize);
490 | }
491 | function XAudioJSGetArraySlice(buffer, lengthOf) {
492 | 	//Typed array and normal array buffer section referencing:
493 | 	try {
494 | 		return buffer.subarray(0, lengthOf);
495 | 	}
496 | 	catch (error) {
497 | 		try {
498 | 			//Regular array pass:
499 | 			buffer.length = lengthOf;
500 | 			return buffer;
501 | 		}
502 | 		catch (error) {
503 | 			//Nightly Firefox 4 used to have the subarray function named as slice:
504 | 			return buffer.slice(0, lengthOf);
505 | 		}
506 | 	}
507 | }


--------------------------------------------------------------------------------
/js/other/XAudioServerMediaStreamWorker.js:
--------------------------------------------------------------------------------
 1 | //This file is part of the XAudioJS library.
 2 | var XAudioJSResampledBuffer = [];
 3 | var XAudioJSOutputBuffer = [];
 4 | var XAudioJSResampleBufferStart = 0;
 5 | var XAudioJSResampleBufferEnd = 0;
 6 | var XAudioJSResampleBufferSize = 0;
 7 | var XAudioJSChannelsAllocated = 1;
 8 | //Message Receiver:
 9 | self.onmessage = function (event) {
10 | 	var data = event.data;
11 | 	switch (data[0]) {
12 | 		case 0:
13 | 			//Add new audio samples to our ring buffer:
14 | 			var resampledResult = data[1];
15 | 			var length = resampledResult.length;
16 | 			for (var i = 0; i < length; ++i) {
17 | 				XAudioJSResampledBuffer[XAudioJSResampleBufferEnd++] = resampledResult[i];
18 | 				if (XAudioJSResampleBufferEnd == XAudioJSResampleBufferSize) {
19 | 					XAudioJSResampleBufferEnd = 0;
20 | 				}
21 | 				if (XAudioJSResampleBufferStart == XAudioJSResampleBufferEnd) {
22 | 					XAudioJSResampleBufferStart += XAudioJSChannelsAllocated;
23 | 					if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
24 | 						XAudioJSResampleBufferStart = 0;
25 | 					}
26 | 				}
27 | 			}
28 | 			break;
29 | 		case 1:
30 | 			//Initialize:
31 | 			XAudioJSResampleBufferSize = data[1];
32 | 			XAudioJSChannelsAllocated = data[2];
33 | 			XAudioJSResampledBuffer = new Float32Array(XAudioJSResampleBufferSize);
34 | 	}
35 | }
36 | //MediaStream Polyfill Event:
37 | self.onprocessmedia = function (event) {
38 | 	//Get some buffer length computations:
39 | 	var apiBufferLength = event.audioLength;
40 | 	var apiBufferLengthAll = apiBufferLength * event.audioChannels;
41 | 	if (apiBufferLengthAll > XAudioJSOutputBuffer.length) {
42 | 		XAudioJSOutputBuffer = new Float32Array(apiBufferLengthAll);
43 | 	}
44 | 	//De-interleave the buffered audio while looping through our ring buffer:
45 | 	var sampleFramesCount = Math.min(apiBufferLength, XAudioJSResampledSamplesLeft() / XAudioJSChannelsAllocated);
46 | 	for (var sampleFramePosition = 0, channelOffset = 0; sampleFramePosition < sampleFramesCount; ++sampleFramePosition) {
47 | 		for (channelOffset = sampleFramePosition; channelOffset < apiBufferLengthAll; channelOffset += apiBufferLength) {
48 | 			XAudioJSOutputBuffer[channelOffset] = XAudioJSResampledBuffer[XAudioJSResampleBufferStart++];
49 | 			if (XAudioJSResampleBufferStart == XAudioJSResampleBufferSize) {
50 | 				XAudioJSResampleBufferStart = 0;
51 | 			}
52 | 		}
53 | 	}
54 | 	//Add some zero fill if we underran the required buffer fill amount:
55 | 	while (sampleFramePosition < apiBufferLength) {
56 | 		for (channelOffset = sampleFramePosition++; channelOffset < apiBufferLengthAll; channelOffset += apiBufferLength) {
57 | 			XAudioJSOutputBuffer[channelOffset] = 0;
58 | 		}
59 | 	}
60 | 	//Write some buffered audio:
61 | 	event.writeAudio(XAudioJSOutputBuffer.subarray(0, apiBufferLengthAll));
62 | 	//Request a buffer from the main thread:
63 | 	self.postMessage(event.audioLength);
64 | }
65 | //Accessory function used to determine remaining samples in the ring buffer:
66 | function XAudioJSResampledSamplesLeft() {
67 | 	return ((XAudioJSResampleBufferStart <= XAudioJSResampleBufferEnd) ? 0 : XAudioJSResampleBufferSize) + XAudioJSResampleBufferEnd - XAudioJSResampleBufferStart;
68 | }


--------------------------------------------------------------------------------
/js/other/base64.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var toBase64 = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
 3 | 	"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
 4 | 	"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+" , "/", "="];
 5 | var fromBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 6 | function base64(data) {
 7 | 	try {
 8 | 		var base64 = window.btoa(data);	//Use this native function when it's available, as it's a magnitude faster than the non-native code below.
 9 | 	}
10 | 	catch (error) {
11 | 		//Defaulting to non-native base64 encoding...
12 | 		var base64 = "";
13 | 		var dataLength = data.length;
14 | 		if (dataLength > 0) {
15 | 			var bytes = [0, 0, 0];
16 | 			var index = 0;
17 | 			var remainder = dataLength % 3;
18 | 			while (data.length % 3 > 0) {
19 | 				//Make sure we don't do fuzzy math in the next loop...
20 | 				data[data.length] = " ";
21 | 			}
22 | 			while (index < dataLength) {
23 | 				//Keep this loop small for speed.
24 | 				bytes = [data.charCodeAt(index++) & 0xFF, data.charCodeAt(index++) & 0xFF, data.charCodeAt(index++) & 0xFF];
25 | 				base64 += toBase64[bytes[0] >> 2] + toBase64[((bytes[0] & 0x3) << 4) | (bytes[1] >> 4)] + toBase64[((bytes[1] & 0xF) << 2) | (bytes[2] >> 6)] + toBase64[bytes[2] & 0x3F];
26 | 			}
27 | 			if (remainder > 0) {
28 | 				//Fill in the padding and recalulate the trailing six-bit group...
29 | 				base64[base64.length - 1] = "=";
30 | 				if (remainder == 2) {
31 | 					base64[base64.length - 2] = "=";
32 | 					base64[base64.length - 3] = toBase64[(bytes[0] & 0x3) << 4];
33 | 				}
34 | 				else {
35 | 					base64[base64.length - 2] = toBase64[(bytes[1] & 0xF) << 2];
36 | 				}
37 | 			}
38 | 		}
39 | 	}
40 | 	return base64;
41 | }
42 | function base64_decode(data) {
43 | 	try {
44 | 		var decode64 = window.atob(data);	//Use this native function when it's available, as it's a magnitude faster than the non-native code below.
45 | 	}
46 | 	catch (error) {
47 | 		//Defaulting to non-native base64 decoding...
48 | 		var decode64 = "";
49 | 		var dataLength = data.length;
50 | 		if (dataLength > 3 && dataLength % 4 == 0) {
51 | 			var sixbits = [0, 0, 0, 0];	//Declare this out of the loop, to speed up the ops.
52 | 			var index = 0;
53 | 			while (index < dataLength) {
54 | 				//Keep this loop small for speed.
55 | 				sixbits = [fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++))];
56 | 				decode64 += String.fromCharCode((sixbits[0] << 2) | (sixbits[1] >> 4)) + String.fromCharCode(((sixbits[1] & 0x0F) << 4) | (sixbits[2] >> 2)) + String.fromCharCode(((sixbits[2] & 0x03) << 6) | sixbits[3]);
57 | 			}
58 | 			//Check for the '=' character after the loop, so we don't hose it up.
59 | 			if (sixbits[3] >= 0x40) {
60 | 				decode64.length -= 1;
61 | 				if (sixbits[2] >= 0x40) {
62 | 					decode64.length -= 1;
63 | 				}
64 | 			}
65 | 		}
66 | 	}
67 | 	return decode64;
68 | }
69 | function to_little_endian_dword(str) {
70 | 	return to_little_endian_word(str) + to_little_endian_word(str >> 16);
71 | }
72 | function to_little_endian_word(str) {
73 | 	return to_byte(str) + to_byte(str >> 8);
74 | }
75 | function to_byte(str) {
76 | 	return String.fromCharCode(str & 0xFF);
77 | }
78 | function arrayToBase64(arrayIn) {
79 | 	var binString = "";
80 | 	var length = arrayIn.length;
81 | 	for (var index = 0; index < length; ++index) {
82 | 		if (typeof arrayIn[index] == "number") {
83 | 			binString += String.fromCharCode(arrayIn[index]);
84 | 		}
85 | 	}
86 | 	return base64(binString);
87 | }
88 | function base64ToArray(b64String) {
89 | 	var binString = base64_decode(b64String);
90 | 	var outArray = [];
91 | 	var length = binString.length;
92 | 	for (var index = 0; index < length;) {
93 | 		outArray.push(binString.charCodeAt(index++) & 0xFF);
94 | 	}
95 | 	return outArray;
96 | }


--------------------------------------------------------------------------------
/js/other/gui.js:
--------------------------------------------------------------------------------
  1 | var inFullscreen = false;
  2 | var mainCanvas = null;
  3 | var fullscreenCanvas = null;
  4 | var showAsMinimal = false;
  5 | var keyZones = [
  6 | 	["right", [39]],
  7 | 	["left", [37]],
  8 | 	["up", [38]],
  9 | 	["down", [40]],
 10 | 	["a", [88, 74]],
 11 | 	["b", [90, 81, 89]],
 12 | 	["select", [16]],
 13 | 	["start", [13]]
 14 | ];
 15 | function windowingInitialize() {
 16 | 	cout("windowingInitialize() called.", 0);
 17 | 	windowStacks[0] = windowCreate("GameBoy", true);
 18 | 	windowStacks[1] = windowCreate("terminal", false);
 19 | 	windowStacks[2] = windowCreate("about", false);
 20 | 	windowStacks[3] = windowCreate("settings", false);
 21 | 	windowStacks[4] = windowCreate("input_select", false);
 22 | 	windowStacks[5] = windowCreate("instructions", false);
 23 | 	windowStacks[6] = windowCreate("local_storage_popup", false);
 24 | 	windowStacks[7] = windowCreate("local_storage_listing", false);
 25 | 	windowStacks[8] = windowCreate("freeze_listing", false);
 26 | 	windowStacks[9] = windowCreate("save_importer", false);
 27 | 	mainCanvas = document.getElementById("mainCanvas");
 28 | 	fullscreenCanvas = document.getElementById("fullscreen");
 29 | 	try {
 30 | 		//Hook the GUI controls.
 31 | 		registerGUIEvents();
 32 | 	}
 33 | 	catch (error) {
 34 | 		cout("Fatal windowing error: \"" + error.message + "\" file:" + error.fileName + " line: " + error.lineNumber, 2);
 35 | 	}
 36 | 	//Update the settings to the emulator's default:
 37 | 	document.getElementById("enable_sound").checked = settings[0];
 38 | 	document.getElementById("enable_gbc_bios").checked = settings[1];
 39 | 	document.getElementById("disable_colors").checked = settings[2];
 40 | 	document.getElementById("rom_only_override").checked = settings[9];
 41 | 	document.getElementById("mbc_enable_override").checked = settings[10];
 42 | 	document.getElementById("enable_colorization").checked = settings[4];
 43 | 	document.getElementById("do_minimal").checked = showAsMinimal;
 44 | 	document.getElementById("software_resizing").checked = settings[12];
 45 | 	document.getElementById("typed_arrays_disallow").checked = settings[5];
 46 | 	document.getElementById("gb_boot_rom_utilized").checked = settings[11];
 47 | 	document.getElementById("resize_smoothing").checked = settings[13];
 48 |     document.getElementById("channel1").checked = settings[14][0];
 49 |     document.getElementById("channel2").checked = settings[14][1];
 50 |     document.getElementById("channel3").checked = settings[14][2];
 51 |     document.getElementById("channel4").checked = settings[14][3];
 52 | }
 53 | function registerGUIEvents() {
 54 | 	cout("In registerGUIEvents() : Registering GUI Events.", -1);
 55 | 	addEvent("click", document.getElementById("terminal_clear_button"), clear_terminal);
 56 | 	addEvent("click", document.getElementById("local_storage_list_refresh_button"), refreshStorageListing);
 57 | 	addEvent("click", document.getElementById("terminal_close_button"), function () { windowStacks[1].hide() });
 58 | 	addEvent("click", document.getElementById("about_close_button"), function () { windowStacks[2].hide() });
 59 | 	addEvent("click", document.getElementById("settings_close_button"), function () { windowStacks[3].hide() });
 60 | 	addEvent("click", document.getElementById("input_select_close_button"), function () { windowStacks[4].hide() });
 61 | 	addEvent("click", document.getElementById("instructions_close_button"), function () { windowStacks[5].hide() });
 62 | 	addEvent("click", document.getElementById("local_storage_list_close_button"), function () { windowStacks[7].hide() });
 63 | 	addEvent("click", document.getElementById("local_storage_popup_close_button"), function () { windowStacks[6].hide() });
 64 | 	addEvent("click", document.getElementById("save_importer_close_button"), function () { windowStacks[9].hide() });
 65 | 	addEvent("click", document.getElementById("freeze_list_close_button"), function () { windowStacks[8].hide() });
 66 | 	addEvent("click", document.getElementById("GameBoy_about_menu"), function () { windowStacks[2].show() });
 67 | 	addEvent("click", document.getElementById("GameBoy_settings_menu"), function () { windowStacks[3].show() });
 68 | 	addEvent("click", document.getElementById("local_storage_list_menu"), function () { refreshStorageListing(); windowStacks[7].show(); });
 69 | 	addEvent("click", document.getElementById("freeze_list_menu"), function () { refreshFreezeListing(); windowStacks[8].show(); });
 70 | 	addEvent("click", document.getElementById("view_importer"), function () { windowStacks[9].show() });
 71 | 	addEvent("keydown", document, keyDown);
 72 | 	addEvent("keyup", document,  function (event) {
 73 | 		if (event.keyCode == 27) {
 74 | 			//Fullscreen on/off
 75 | 			fullscreenPlayer();
 76 | 		}
 77 | 		else {
 78 | 			//Control keys / other
 79 | 			keyUp(event);
 80 | 		}
 81 | 	});
 82 | 	addEvent("MozOrientation", window, GameBoyGyroSignalHandler);
 83 | 	addEvent("deviceorientation", window, GameBoyGyroSignalHandler);
 84 | 	new popupMenu(document.getElementById("GameBoy_file_menu"), document.getElementById("GameBoy_file_popup"));
 85 | 	addEvent("click", document.getElementById("data_uri_clicker"), function () {
 86 | 		var datauri = prompt("Please input the ROM image's Base 64 Encoded Text:", "");
 87 | 		if (datauri != null && datauri.length > 0) {
 88 | 			try {
 89 | 				cout(Math.floor(datauri.length * 3 / 4) + " bytes of data submitted by form (text length of " + datauri.length + ").", 0);
 90 | 				initPlayer();
 91 | 				start(mainCanvas, base64_decode(datauri));
 92 | 			}
 93 | 			catch (error) {
 94 | 				alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
 95 | 			}
 96 | 		}
 97 | 	});
 98 | 	addEvent("click", document.getElementById("set_volume"), function () {
 99 | 		if (GameBoyEmulatorInitialized()) {
100 | 			var volume = prompt("Set the volume here:", "1.0");
101 | 			if (volume != null && volume.length > 0) {
102 | 				settings[3] = Math.min(Math.max(parseFloat(volume), 0), 1);
103 | 				gameboy.changeVolume();
104 | 			}
105 | 		}
106 | 	});
107 | 	addEvent("click", document.getElementById("set_speed"), function () {
108 | 		if (GameBoyEmulatorInitialized()) {
109 | 			var speed = prompt("Set the emulator speed here:", "1.0");
110 | 			if (speed != null && speed.length > 0) {
111 | 				gameboy.setSpeed(Math.max(parseFloat(speed), 0.001));
112 | 			}
113 | 		}
114 | 	});
115 | 	addEvent("click", document.getElementById("internal_file_clicker"), function () {
116 | 		var file_opener = document.getElementById("local_file_open");
117 | 		windowStacks[4].show();
118 | 		file_opener.click();
119 | 	});
120 | 	addEvent("blur", document.getElementById("input_select"), function () {
121 | 		windowStacks[4].hide();
122 | 	});
123 | 	addEvent("change", document.getElementById("local_file_open"), function () {
124 | 		windowStacks[4].hide();
125 | 		if (typeof this.files != "undefined") {
126 | 			try {
127 | 				if (this.files.length >= 1) {
128 | 					cout("Reading the local file \"" + this.files[0].name + "\"", 0);
129 | 					try {
130 | 						//Gecko 1.9.2+ (Standard Method)
131 | 						var binaryHandle = new FileReader();
132 | 						binaryHandle.onload = function () {
133 | 							if (this.readyState == 2) {
134 | 								cout("file loaded.", 0);
135 | 								try {
136 | 									initPlayer();
137 | 									start(mainCanvas, this.result);
138 | 								}
139 | 								catch (error) {
140 | 									alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
141 | 								}
142 | 							}
143 | 							else {
144 | 								cout("loading file, please wait...", 0);
145 | 							}
146 | 						}
147 | 						binaryHandle.readAsBinaryString(this.files[this.files.length - 1]);
148 | 					}
149 | 					catch (error) {
150 | 						cout("Browser does not support the FileReader object, falling back to the non-standard File object access,", 2);
151 | 						//Gecko 1.9.0, 1.9.1 (Non-Standard Method)
152 | 						var romImageString = this.files[this.files.length - 1].getAsBinary();
153 | 						try {
154 | 							initPlayer();
155 | 							start(mainCanvas, romImageString);
156 | 						}
157 | 						catch (error) {
158 | 							alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
159 | 						}
160 | 						
161 | 					}
162 | 				}
163 | 				else {
164 | 					cout("Incorrect number of files selected for local loading.", 1);
165 | 				}
166 | 			}
167 | 			catch (error) {
168 | 				cout("Could not load in a locally stored ROM file.", 2);
169 | 			}
170 | 		}
171 | 		else {
172 | 			cout("could not find the handle on the file to open.", 2);
173 | 		}
174 | 	});
175 | 	addEvent("change", document.getElementById("save_open"), function () {
176 | 		windowStacks[9].hide();
177 | 		if (typeof this.files != "undefined") {
178 | 			try {
179 | 				if (this.files.length >= 1) {
180 | 					cout("Reading the local file \"" + this.files[0].name + "\" for importing.", 0);
181 | 					try {
182 | 						//Gecko 1.9.2+ (Standard Method)
183 | 						var binaryHandle = new FileReader();
184 | 						binaryHandle.onload = function () {
185 | 							if (this.readyState == 2) {
186 | 								cout("file imported.", 0);
187 | 								try {
188 | 									import_save(this.result);
189 | 									refreshStorageListing();
190 | 								}
191 | 								catch (error) {
192 | 									alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
193 | 								}
194 | 							}
195 | 							else {
196 | 								cout("importing file, please wait...", 0);
197 | 							}
198 | 						}
199 | 						binaryHandle.readAsBinaryString(this.files[this.files.length - 1]);
200 | 					}
201 | 					catch (error) {
202 | 						cout("Browser does not support the FileReader object, falling back to the non-standard File object access,", 2);
203 | 						//Gecko 1.9.0, 1.9.1 (Non-Standard Method)
204 | 						var romImageString = this.files[this.files.length - 1].getAsBinary();
205 | 						try {
206 | 							import_save(romImageString);
207 | 							refreshStorageListing();
208 | 						}
209 | 						catch (error) {
210 | 							alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
211 | 						}
212 | 						
213 | 					}
214 | 				}
215 | 				else {
216 | 					cout("Incorrect number of files selected for local loading.", 1);
217 | 				}
218 | 			}
219 | 			catch (error) {
220 | 				cout("Could not load in a locally stored ROM file.", 2);
221 | 			}
222 | 		}
223 | 		else {
224 | 			cout("could not find the handle on the file to open.", 2);
225 | 		}
226 | 	});
227 | 	addEvent("click", document.getElementById("restart_cpu_clicker"), function () {
228 | 		if (GameBoyEmulatorInitialized()) {
229 | 			try {
230 | 				if (!gameboy.fromSaveState) {
231 | 					initPlayer();
232 | 					start(mainCanvas, gameboy.getROMImage());
233 | 				}
234 | 				else {
235 | 					initPlayer();
236 | 					openState(gameboy.savedStateFileName, mainCanvas);
237 | 				}
238 | 			}
239 | 			catch (error) {
240 | 				alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
241 | 			}
242 | 		}
243 | 		else {
244 | 			cout("Could not restart, as a previous emulation session could not be found.", 1);
245 | 		}
246 | 	});
247 | 	addEvent("click", document.getElementById("run_cpu_clicker"), function () {
248 | 		run();
249 | 	});
250 | 	addEvent("click", document.getElementById("kill_cpu_clicker"), function () {
251 | 		pause();
252 | 	});
253 | 	addEvent("click", document.getElementById("save_state_clicker"), function () {
254 | 		save();
255 | 	});
256 | 	addEvent("click", document.getElementById("save_SRAM_state_clicker"), function () {
257 | 		saveSRAM();
258 | 	});
259 | 	addEvent("click", document.getElementById("enable_sound"), function () {
260 | 		settings[0] = document.getElementById("enable_sound").checked;
261 | 		if (GameBoyEmulatorInitialized()) {
262 | 			gameboy.initSound();
263 | 		}
264 | 	});
265 | 	addEvent("click", document.getElementById("disable_colors"), function () {
266 | 		settings[2] = document.getElementById("disable_colors").checked;
267 | 	});
268 | 	addEvent("click", document.getElementById("rom_only_override"), function () {
269 | 		settings[9] = document.getElementById("rom_only_override").checked;
270 | 	});
271 | 	addEvent("click", document.getElementById("mbc_enable_override"), function () {
272 | 		settings[10] = document.getElementById("mbc_enable_override").checked;
273 | 	});
274 | 	addEvent("click", document.getElementById("enable_gbc_bios"), function () {
275 | 		settings[1] = document.getElementById("enable_gbc_bios").checked;
276 | 	});
277 | 	addEvent("click", document.getElementById("enable_colorization"), function () {
278 | 		settings[4] = document.getElementById("enable_colorization").checked;
279 | 	});
280 | 	addEvent("click", document.getElementById("do_minimal"), function () {
281 | 		showAsMinimal = document.getElementById("do_minimal").checked;
282 | 		fullscreenCanvas.className = (showAsMinimal) ? "minimum" : "maximum";
283 | 	});
284 | 	addEvent("click", document.getElementById("software_resizing"), function () {
285 | 		settings[12] = document.getElementById("software_resizing").checked;
286 | 		if (GameBoyEmulatorInitialized()) {
287 | 			gameboy.initLCD();
288 | 		}
289 | 	});
290 | 	addEvent("click", document.getElementById("typed_arrays_disallow"), function () {
291 | 		settings[5] = document.getElementById("typed_arrays_disallow").checked;
292 | 	});
293 | 	addEvent("click", document.getElementById("gb_boot_rom_utilized"), function () {
294 | 		settings[11] = document.getElementById("gb_boot_rom_utilized").checked;
295 | 	});
296 | 	addEvent("click", document.getElementById("resize_smoothing"), function () {
297 | 		settings[13] = document.getElementById("resize_smoothing").checked;
298 | 		if (GameBoyEmulatorInitialized()) {
299 | 			gameboy.initLCD();
300 | 		}
301 | 	});
302 |     addEvent("click", document.getElementById("channel1"), function () {
303 |         settings[14][0] = document.getElementById("channel1").checked;
304 |     });
305 |     addEvent("click", document.getElementById("channel2"), function () {
306 |         settings[14][1] = document.getElementById("channel2").checked;
307 |     });
308 |     addEvent("click", document.getElementById("channel3"), function () {
309 |         settings[14][2] = document.getElementById("channel3").checked;
310 |     });
311 |     addEvent("click", document.getElementById("channel4"), function () {
312 |         settings[14][3] = document.getElementById("channel4").checked;
313 |     });
314 | 	addEvent("click", document.getElementById("view_fullscreen"), fullscreenPlayer);
315 | 	new popupMenu(document.getElementById("GameBoy_view_menu"), document.getElementById("GameBoy_view_popup"));
316 | 	addEvent("click", document.getElementById("view_terminal"), function () { windowStacks[1].show() });
317 | 	addEvent("click", document.getElementById("view_instructions"), function () { windowStacks[5].show() });
318 | 	addEvent("mouseup", document.getElementById("gfx"), initNewCanvasSize);
319 | 	addEvent("resize", window, initNewCanvasSize);
320 | 	addEvent("unload", window, function () {
321 | 		autoSave();
322 | 	});
323 | }
324 | function keyDown(event) {
325 | 	var keyCode = event.keyCode;
326 | 	var keyMapLength = keyZones.length;
327 | 	for (var keyMapIndex = 0; keyMapIndex < keyMapLength; ++keyMapIndex) {
328 | 		var keyCheck = keyZones[keyMapIndex];
329 | 		var keysMapped = keyCheck[1];
330 | 		var keysTotal = keysMapped.length;
331 | 		for (var index = 0; index < keysTotal; ++index) {
332 | 			if (keysMapped[index] == keyCode) {
333 | 				GameBoyKeyDown(keyCheck[0]);
334 | 				try {
335 | 					event.preventDefault();
336 | 				}
337 | 				catch (error) { }
338 | 			}
339 | 		}
340 | 	}
341 | }
342 | function keyUp(event) {
343 | 	var keyCode = event.keyCode;
344 | 	var keyMapLength = keyZones.length;
345 | 	for (var keyMapIndex = 0; keyMapIndex < keyMapLength; ++keyMapIndex) {
346 | 		var keyCheck = keyZones[keyMapIndex];
347 | 		var keysMapped = keyCheck[1];
348 | 		var keysTotal = keysMapped.length;
349 | 		for (var index = 0; index < keysTotal; ++index) {
350 | 			if (keysMapped[index] == keyCode) {
351 | 				GameBoyKeyUp(keyCheck[0]);
352 | 				try {
353 | 					event.preventDefault();
354 | 				}
355 | 				catch (error) { }
356 | 			}
357 | 		}
358 | 	}
359 | }
360 | function initPlayer() {
361 | 	document.getElementById("title").style.display = "none";
362 | 	document.getElementById("port_title").style.display = "none";
363 | 	document.getElementById("fullscreenContainer").style.display = "none";
364 | }
365 | function fullscreenPlayer() {
366 | 	if (GameBoyEmulatorInitialized()) {
367 | 		if (!inFullscreen) {
368 | 			gameboy.canvas = fullscreenCanvas;
369 | 			fullscreenCanvas.className = (showAsMinimal) ? "minimum" : "maximum";
370 | 			document.getElementById("fullscreenContainer").style.display = "block";
371 | 			windowStacks[0].hide();
372 | 		}
373 | 		else {
374 | 			gameboy.canvas = mainCanvas;
375 | 			document.getElementById("fullscreenContainer").style.display = "none";
376 | 			windowStacks[0].show();
377 | 		}
378 | 		gameboy.initLCD();
379 | 		inFullscreen = !inFullscreen;
380 | 	}
381 | 	else {
382 | 		cout("Cannot go into fullscreen mode.", 2);
383 | 	}
384 | }
385 | function runFreeze(keyName) {
386 | 	try {
387 | 		windowStacks[8].hide();
388 | 		initPlayer();
389 | 		openState(keyName, mainCanvas);
390 | 	}
391 | 	catch (error) {
392 | 		cout("A problem with attempting to open the selected save state occurred.", 2);
393 | 	}
394 | }
395 | //Wrapper for localStorage getItem, so that data can be retrieved in various types.
396 | function findValue(key) {
397 | 	try {
398 | 		if (window.localStorage.getItem(key) != null) {
399 | 			return JSON.parse(window.localStorage.getItem(key));
400 | 		}
401 | 	}
402 | 	catch (error) {
403 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
404 | 		if (window.globalStorage[location.hostname].getItem(key) != null) {
405 | 			return JSON.parse(window.globalStorage[location.hostname].getItem(key));
406 | 		}
407 | 	}
408 | 	return null;
409 | }
410 | //Wrapper for localStorage setItem, so that data can be set in various types.
411 | function setValue(key, value) {
412 | 	try {
413 | 		window.localStorage.setItem(key, JSON.stringify(value));
414 | 	}
415 | 	catch (error) {
416 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
417 | 		window.globalStorage[location.hostname].setItem(key, JSON.stringify(value));
418 | 	}
419 | }
420 | //Wrapper for localStorage removeItem, so that data can be set in various types.
421 | function deleteValue(key) {
422 | 	try {
423 | 		window.localStorage.removeItem(key);
424 | 	}
425 | 	catch (error) {
426 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
427 | 		window.globalStorage[location.hostname].removeItem(key);
428 | 	}
429 | }
430 | function outputLocalStorageLink(keyName, dataFound, downloadName) {
431 | 	return generateDownloadLink("data:application/octet-stream;base64," + dataFound, keyName, downloadName);
432 | }
433 | function refreshFreezeListing() {
434 | 	var storageListMasterDivSub = document.getElementById("freezeListingMasterContainerSub");
435 | 	var storageListMasterDiv = document.getElementById("freezeListingMasterContainer");
436 | 	storageListMasterDiv.removeChild(storageListMasterDivSub);
437 | 	storageListMasterDivSub = document.createElement("div");
438 | 	storageListMasterDivSub.id = "freezeListingMasterContainerSub";
439 | 	var keys = getLocalStorageKeys();
440 | 	while (keys.length > 0) {
441 | 		key = keys.shift();
442 | 		if (key.substring(0, 7) == "FREEZE_") {
443 | 			storageListMasterDivSub.appendChild(outputFreezeStateRequestLink(key));
444 | 		}
445 | 	}
446 | 	storageListMasterDiv.appendChild(storageListMasterDivSub);
447 | }
448 | function outputFreezeStateRequestLink(keyName) {
449 | 	var linkNode = generateLink("javascript:runFreeze(\"" + keyName + "\")", keyName);
450 | 	var storageContainerDiv = document.createElement("div");
451 | 	storageContainerDiv.className = "storageListingContainer";
452 | 	storageContainerDiv.appendChild(linkNode)
453 | 	return storageContainerDiv;
454 | }
455 | function refreshStorageListing() {
456 | 	var storageListMasterDivSub = document.getElementById("storageListingMasterContainerSub");
457 | 	var storageListMasterDiv = document.getElementById("storageListingMasterContainer");
458 | 	storageListMasterDiv.removeChild(storageListMasterDivSub);
459 | 	storageListMasterDivSub = document.createElement("div");
460 | 	storageListMasterDivSub.id = "storageListingMasterContainerSub";
461 | 	var keys = getLocalStorageKeys();
462 | 	var blobPairs = [];
463 | 	for (var index = 0; index < keys.length; ++index) {
464 | 		blobPairs[index] = getBlobPreEncoded(keys[index]);
465 | 		storageListMasterDivSub.appendChild(outputLocalStorageRequestLink(keys[index]));
466 | 	}
467 | 	storageListMasterDiv.appendChild(storageListMasterDivSub);
468 | 	var linkToManipulate = document.getElementById("download_local_storage_dba");
469 | 	linkToManipulate.href = "data:application/octet-stream;base64," + base64(generateMultiBlob(blobPairs));
470 | 	linkToManipulate.download = "gameboy_color_saves.export";
471 | }
472 | function getBlobPreEncoded(keyName) {
473 | 	if (keyName.substring(0, 9) == "B64_SRAM_") {
474 | 		return [keyName.substring(4), base64_decode(findValue(keyName))];
475 | 	}
476 | 	else if (keyName.substring(0, 5) == "SRAM_") {
477 | 		return [keyName, convertToBinary(findValue(keyName))];
478 | 	}
479 | 	else {
480 | 		return [keyName, JSON.stringify(findValue(keyName))];
481 | 	}
482 | }
483 | function outputLocalStorageRequestLink(keyName) {
484 | 	var linkNode = generateLink("javascript:popupStorageDialog(\"" + keyName + "\")", keyName);
485 | 	var storageContainerDiv = document.createElement("div");
486 | 	storageContainerDiv.className = "storageListingContainer";
487 | 	storageContainerDiv.appendChild(linkNode)
488 | 	return storageContainerDiv;
489 | }
490 | function popupStorageDialog(keyName) {
491 | 	var subContainer = document.getElementById("storagePopupMasterContainer");
492 | 	var parentContainer = document.getElementById("storagePopupMasterParent");
493 | 	parentContainer.removeChild(subContainer);
494 | 	subContainer = document.createElement("div");
495 | 	subContainer.id = "storagePopupMasterContainer";
496 | 	parentContainer.appendChild(subContainer);
497 | 	var downloadDiv = document.createElement("div");
498 | 	downloadDiv.id = "storagePopupDownload";
499 | 	if (keyName.substring(0, 9) == "B64_SRAM_") {
500 | 		var downloadDiv2 = document.createElement("div");
501 | 		downloadDiv2.id = "storagePopupDownloadRAW";
502 | 		downloadDiv2.appendChild(outputLocalStorageLink("Download RAW save data.", findValue(keyName), keyName));
503 | 		subContainer.appendChild(downloadDiv2);
504 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName.substring(4), base64_decode(findValue(keyName)))), keyName));
505 | 	}
506 | 	else if (keyName.substring(0, 5) == "SRAM_") {
507 | 		var downloadDiv2 = document.createElement("div");
508 | 		downloadDiv2.id = "storagePopupDownloadRAW";
509 | 		downloadDiv2.appendChild(outputLocalStorageLink("Download RAW save data.", base64(convertToBinary(findValue(keyName))), keyName));
510 | 		subContainer.appendChild(downloadDiv2);
511 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName, convertToBinary(findValue(keyName)))), keyName));
512 | 	}
513 | 	else {
514 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName, JSON.stringify(findValue(keyName)))), keyName));
515 | 	}
516 | 	var deleteLink = generateLink("javascript:deleteStorageSlot(\"" + keyName + "\")", "Delete data item from HTML5 local storage.");
517 | 	deleteLink.id = "storagePopupDelete";
518 | 	subContainer.appendChild(downloadDiv);
519 | 	subContainer.appendChild(deleteLink);
520 | 	windowStacks[6].show();
521 | }
522 | function convertToBinary(jsArray) {
523 | 	var length = jsArray.length;
524 | 	var binString = "";
525 | 	for (var indexBin = 0; indexBin < length; indexBin++) {
526 | 		binString += String.fromCharCode(jsArray[indexBin]);
527 | 	}
528 | 	return binString;
529 | }
530 | function deleteStorageSlot(keyName) {
531 | 	deleteValue(keyName);
532 | 	windowStacks[6].hide();
533 | 	refreshStorageListing();
534 | }
535 | function generateLink(address, textData) {
536 | 	var link = document.createElement("a");
537 | 	link.href = address;
538 | 	link.appendChild(document.createTextNode(textData));
539 | 	return link;
540 | }
541 | function generateDownloadLink(address, textData, keyName) {
542 | 	var link = generateLink(address, textData);
543 | 	link.download = keyName + ".sav";
544 | 	return link;
545 | }
546 | function checkStorageLength() {
547 | 	try {
548 | 		return window.localStorage.length;
549 | 	}
550 | 	catch (error) {
551 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
552 | 		return window.globalStorage[location.hostname].length;
553 | 	}
554 | }
555 | function getLocalStorageKeys() {
556 | 	var storageLength = checkStorageLength();
557 | 	var keysFound = [];
558 | 	var index = 0;
559 | 	var nextKey = null;
560 | 	while (index < storageLength) {
561 | 		nextKey = findKey(index++);
562 | 		if (nextKey !== null && nextKey.length > 0) {
563 | 			if (nextKey.substring(0, 5) == "SRAM_" || nextKey.substring(0, 9) == "B64_SRAM_" || nextKey.substring(0, 7) == "FREEZE_" || nextKey.substring(0, 4) == "RTC_") {
564 | 				keysFound.push(nextKey);
565 | 			}
566 | 		}
567 | 		else {
568 | 			break;
569 | 		}
570 | 	}
571 | 	return keysFound;
572 | }
573 | function findKey(keyNum) {
574 | 	try {
575 | 		return window.localStorage.key(keyNum);
576 | 	}
577 | 	catch (error) {
578 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
579 | 		return window.globalStorage[location.hostname].key(keyNum);
580 | 	}
581 | 	return null;
582 | }
583 | //Some wrappers and extensions for non-DOM3 browsers:
584 | function isDescendantOf(ParentElement, toCheck) {
585 | 	if (!ParentElement || !toCheck) {
586 | 		return false;
587 | 	}
588 | 	//Verify an object as either a direct or indirect child to another object.
589 | 	function traverseTree(domElement) {
590 | 		while (domElement != null) {
591 | 			if (domElement.nodeType == 1) {
592 | 				if (isSameNode(domElement, toCheck)) {
593 | 					return true;
594 | 				}
595 | 				if (hasChildNodes(domElement)) {
596 | 					if (traverseTree(domElement.firstChild)) {
597 | 						return true;
598 | 					}
599 | 				}
600 | 			}
601 | 			domElement = domElement.nextSibling;
602 | 		}
603 | 		return false;
604 | 	}
605 | 	return traverseTree(ParentElement.firstChild);
606 | }
607 | function hasChildNodes(oElement) {
608 | 	return (typeof oElement.hasChildNodes == "function") ? oElement.hasChildNodes() : ((oElement.firstChild != null) ? true : false);
609 | }
610 | function isSameNode(oCheck1, oCheck2) {
611 | 	return (typeof oCheck1.isSameNode == "function") ? oCheck1.isSameNode(oCheck2) : (oCheck1 === oCheck2);
612 | }
613 | function pageXCoord(event) {
614 | 	if (typeof event.pageX == "undefined") {
615 | 		return event.clientX + document.documentElement.scrollLeft;
616 | 	}
617 | 	return event.pageX;
618 | }
619 | function pageYCoord(event) {
620 | 	if (typeof event.pageY == "undefined") {
621 | 		return event.clientY + document.documentElement.scrollTop;
622 | 	}
623 | 	return event.pageY;
624 | }
625 | function mouseLeaveVerify(oElement, event) {
626 | 	//Hook target element with onmouseout and use this function to verify onmouseleave.
627 | 	return isDescendantOf(oElement, (typeof event.target != "undefined") ? event.target : event.srcElement) && !isDescendantOf(oElement, (typeof event.relatedTarget != "undefined") ? event.relatedTarget : event.toElement);
628 | }
629 | function mouseEnterVerify(oElement, event) {
630 | 	//Hook target element with onmouseover and use this function to verify onmouseenter.
631 | 	return !isDescendantOf(oElement, (typeof event.target != "undefined") ? event.target : event.srcElement) && isDescendantOf(oElement, (typeof event.relatedTarget != "undefined") ? event.relatedTarget : event.fromElement);
632 | }
633 | function addEvent(sEvent, oElement, fListener) {
634 | 	try {	
635 | 		oElement.addEventListener(sEvent, fListener, false);
636 | 		cout("In addEvent() : Standard addEventListener() called to add a(n) \"" + sEvent + "\" event.", -1);
637 | 	}
638 | 	catch (error) {
639 | 		oElement.attachEvent("on" + sEvent, fListener);	//Pity for IE.
640 | 		cout("In addEvent() : Nonstandard attachEvent() called to add an \"on" + sEvent + "\" event.", -1);
641 | 	}
642 | }
643 | function removeEvent(sEvent, oElement, fListener) {
644 | 	try {	
645 | 		oElement.removeEventListener(sEvent, fListener, false);
646 | 		cout("In removeEvent() : Standard removeEventListener() called to remove a(n) \"" + sEvent + "\" event.", -1);
647 | 	}
648 | 	catch (error) {
649 | 		oElement.detachEvent("on" + sEvent, fListener);	//Pity for IE.
650 | 		cout("In removeEvent() : Nonstandard detachEvent() called to remove an \"on" + sEvent + "\" event.", -1);
651 | 	}
652 | }


--------------------------------------------------------------------------------
/js/other/json2.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |     http://www.JSON.org/json2.js
  3 |     2010-08-25
  4 | 
  5 |     Public Domain.
  6 | 
  7 |     NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
  8 | 
  9 |     See http://www.JSON.org/js.html
 10 | 
 11 | 
 12 |     This code should be minified before deployment.
 13 |     See http://javascript.crockford.com/jsmin.html
 14 | 
 15 |     USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
 16 |     NOT CONTROL.
 17 | 
 18 | 
 19 |     This file creates a global JSON object containing two methods: stringify
 20 |     and parse.
 21 | 
 22 |         JSON.stringify(value, replacer, space)
 23 |             value       any JavaScript value, usually an object or array.
 24 | 
 25 |             replacer    an optional parameter that determines how object
 26 |                         values are stringified for objects. It can be a
 27 |                         function or an array of strings.
 28 | 
 29 |             space       an optional parameter that specifies the indentation
 30 |                         of nested structures. If it is omitted, the text will
 31 |                         be packed without extra whitespace. If it is a number,
 32 |                         it will specify the number of spaces to indent at each
 33 |                         level. If it is a string (such as '\t' or '&nbsp;'),
 34 |                         it contains the characters used to indent at each level.
 35 | 
 36 |             This method produces a JSON text from a JavaScript value.
 37 | 
 38 |             When an object value is found, if the object contains a toJSON
 39 |             method, its toJSON method will be called and the result will be
 40 |             stringified. A toJSON method does not serialize: it returns the
 41 |             value represented by the name/value pair that should be serialized,
 42 |             or undefined if nothing should be serialized. The toJSON method
 43 |             will be passed the key associated with the value, and this will be
 44 |             bound to the value
 45 | 
 46 |             For example, this would serialize Dates as ISO strings.
 47 | 
 48 |                 Date.prototype.toJSON = function (key) {
 49 |                     function f(n) {
 50 |                         // Format integers to have at least two digits.
 51 |                         return n < 10 ? '0' + n : n;
 52 |                     }
 53 | 
 54 |                     return this.getUTCFullYear()   + '-' +
 55 |                          f(this.getUTCMonth() + 1) + '-' +
 56 |                          f(this.getUTCDate())      + 'T' +
 57 |                          f(this.getUTCHours())     + ':' +
 58 |                          f(this.getUTCMinutes())   + ':' +
 59 |                          f(this.getUTCSeconds())   + 'Z';
 60 |                 };
 61 | 
 62 |             You can provide an optional replacer method. It will be passed the
 63 |             key and value of each member, with this bound to the containing
 64 |             object. The value that is returned from your method will be
 65 |             serialized. If your method returns undefined, then the member will
 66 |             be excluded from the serialization.
 67 | 
 68 |             If the replacer parameter is an array of strings, then it will be
 69 |             used to select the members to be serialized. It filters the results
 70 |             such that only members with keys listed in the replacer array are
 71 |             stringified.
 72 | 
 73 |             Values that do not have JSON representations, such as undefined or
 74 |             functions, will not be serialized. Such values in objects will be
 75 |             dropped; in arrays they will be replaced with null. You can use
 76 |             a replacer function to replace those with JSON values.
 77 |             JSON.stringify(undefined) returns undefined.
 78 | 
 79 |             The optional space parameter produces a stringification of the
 80 |             value that is filled with line breaks and indentation to make it
 81 |             easier to read.
 82 | 
 83 |             If the space parameter is a non-empty string, then that string will
 84 |             be used for indentation. If the space parameter is a number, then
 85 |             the indentation will be that many spaces.
 86 | 
 87 |             Example:
 88 | 
 89 |             text = JSON.stringify(['e', {pluribus: 'unum'}]);
 90 |             // text is '["e",{"pluribus":"unum"}]'
 91 | 
 92 | 
 93 |             text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
 94 |             // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
 95 | 
 96 |             text = JSON.stringify([new Date()], function (key, value) {
 97 |                 return this[key] instanceof Date ?
 98 |                     'Date(' + this[key] + ')' : value;
 99 |             });
100 |             // text is '["Date(---current time---)"]'
101 | 
102 | 
103 |         JSON.parse(text, reviver)
104 |             This method parses a JSON text to produce an object or array.
105 |             It can throw a SyntaxError exception.
106 | 
107 |             The optional reviver parameter is a function that can filter and
108 |             transform the results. It receives each of the keys and values,
109 |             and its return value is used instead of the original value.
110 |             If it returns what it received, then the structure is not modified.
111 |             If it returns undefined then the member is deleted.
112 | 
113 |             Example:
114 | 
115 |             // Parse the text. Values that look like ISO date strings will
116 |             // be converted to Date objects.
117 | 
118 |             myData = JSON.parse(text, function (key, value) {
119 |                 var a;
120 |                 if (typeof value === 'string') {
121 |                     a =
122 | /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
123 |                     if (a) {
124 |                         return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
125 |                             +a[5], +a[6]));
126 |                     }
127 |                 }
128 |                 return value;
129 |             });
130 | 
131 |             myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
132 |                 var d;
133 |                 if (typeof value === 'string' &&
134 |                         value.slice(0, 5) === 'Date(' &&
135 |                         value.slice(-1) === ')') {
136 |                     d = new Date(value.slice(5, -1));
137 |                     if (d) {
138 |                         return d;
139 |                     }
140 |                 }
141 |                 return value;
142 |             });
143 | 
144 | 
145 |     This is a reference implementation. You are free to copy, modify, or
146 |     redistribute.
147 | */
148 | 
149 | /*jslint evil: true, strict: false */
150 | 
151 | /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
152 |     call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
153 |     getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
154 |     lastIndex, length, parse, prototype, push, replace, slice, stringify,
155 |     test, toJSON, toString, valueOf
156 | */
157 | 
158 | 
159 | // Create a JSON object only if one does not already exist. We create the
160 | // methods in a closure to avoid creating global variables.
161 | 
162 | if (!this.JSON) {
163 |     this.JSON = {};
164 | }
165 | 
166 | (function () {
167 | 
168 |     function f(n) {
169 |         // Format integers to have at least two digits.
170 |         return n < 10 ? '0' + n : n;
171 |     }
172 | 
173 |     if (typeof Date.prototype.toJSON !== 'function') {
174 | 
175 |         Date.prototype.toJSON = function (key) {
176 | 
177 |             return isFinite(this.valueOf()) ?
178 |                    this.getUTCFullYear()   + '-' +
179 |                  f(this.getUTCMonth() + 1) + '-' +
180 |                  f(this.getUTCDate())      + 'T' +
181 |                  f(this.getUTCHours())     + ':' +
182 |                  f(this.getUTCMinutes())   + ':' +
183 |                  f(this.getUTCSeconds())   + 'Z' : null;
184 |         };
185 | 
186 |         String.prototype.toJSON =
187 |         Number.prototype.toJSON =
188 |         Boolean.prototype.toJSON = function (key) {
189 |             return this.valueOf();
190 |         };
191 |     }
192 | 
193 |     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
194 |         escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
195 |         gap,
196 |         indent,
197 |         meta = {    // table of character substitutions
198 |             '\b': '\\b',
199 |             '\t': '\\t',
200 |             '\n': '\\n',
201 |             '\f': '\\f',
202 |             '\r': '\\r',
203 |             '"' : '\\"',
204 |             '\\': '\\\\'
205 |         },
206 |         rep;
207 | 
208 | 
209 |     function quote(string) {
210 | 
211 | // If the string contains no control characters, no quote characters, and no
212 | // backslash characters, then we can safely slap some quotes around it.
213 | // Otherwise we must also replace the offending characters with safe escape
214 | // sequences.
215 | 
216 |         escapable.lastIndex = 0;
217 |         return escapable.test(string) ?
218 |             '"' + string.replace(escapable, function (a) {
219 |                 var c = meta[a];
220 |                 return typeof c === 'string' ? c :
221 |                     '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
222 |             }) + '"' :
223 |             '"' + string + '"';
224 |     }
225 | 
226 | 
227 |     function str(key, holder) {
228 | 
229 | // Produce a string from holder[key].
230 | 
231 |         var i,          // The loop counter.
232 |             k,          // The member key.
233 |             v,          // The member value.
234 |             length,
235 |             mind = gap,
236 |             partial,
237 |             value = holder[key];
238 | 
239 | // If the value has a toJSON method, call it to obtain a replacement value.
240 | 
241 |         if (value && typeof value === 'object' &&
242 |                 typeof value.toJSON === 'function') {
243 |             value = value.toJSON(key);
244 |         }
245 | 
246 | // If we were called with a replacer function, then call the replacer to
247 | // obtain a replacement value.
248 | 
249 |         if (typeof rep === 'function') {
250 |             value = rep.call(holder, key, value);
251 |         }
252 | 
253 | // What happens next depends on the value's type.
254 | 
255 |         switch (typeof value) {
256 |         case 'string':
257 |             return quote(value);
258 | 
259 |         case 'number':
260 | 
261 | // JSON numbers must be finite. Encode non-finite numbers as null.
262 | 
263 |             return isFinite(value) ? String(value) : 'null';
264 | 
265 |         case 'boolean':
266 |         case 'null':
267 | 
268 | // If the value is a boolean or null, convert it to a string. Note:
269 | // typeof null does not produce 'null'. The case is included here in
270 | // the remote chance that this gets fixed someday.
271 | 
272 |             return String(value);
273 | 
274 | // If the type is 'object', we might be dealing with an object or an array or
275 | // null.
276 | 
277 |         case 'object':
278 | 
279 | // Due to a specification blunder in ECMAScript, typeof null is 'object',
280 | // so watch out for that case.
281 | 
282 |             if (!value) {
283 |                 return 'null';
284 |             }
285 | 
286 | // Make an array to hold the partial results of stringifying this object value.
287 | 
288 |             gap += indent;
289 |             partial = [];
290 | 
291 | // Is the value an array?
292 | 
293 |             if (Object.prototype.toString.apply(value) === '[object Array]') {
294 | 
295 | // The value is an array. Stringify every element. Use null as a placeholder
296 | // for non-JSON values.
297 | 
298 |                 length = value.length;
299 |                 for (i = 0; i < length; i += 1) {
300 |                     partial[i] = str(i, value) || 'null';
301 |                 }
302 | 
303 | // Join all of the elements together, separated with commas, and wrap them in
304 | // brackets.
305 | 
306 |                 v = partial.length === 0 ? '[]' :
307 |                     gap ? '[\n' + gap +
308 |                             partial.join(',\n' + gap) + '\n' +
309 |                                 mind + ']' :
310 |                           '[' + partial.join(',') + ']';
311 |                 gap = mind;
312 |                 return v;
313 |             }
314 | 
315 | // If the replacer is an array, use it to select the members to be stringified.
316 | 
317 |             if (rep && typeof rep === 'object') {
318 |                 length = rep.length;
319 |                 for (i = 0; i < length; i += 1) {
320 |                     k = rep[i];
321 |                     if (typeof k === 'string') {
322 |                         v = str(k, value);
323 |                         if (v) {
324 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
325 |                         }
326 |                     }
327 |                 }
328 |             } else {
329 | 
330 | // Otherwise, iterate through all of the keys in the object.
331 | 
332 |                 for (k in value) {
333 |                     if (Object.hasOwnProperty.call(value, k)) {
334 |                         v = str(k, value);
335 |                         if (v) {
336 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
337 |                         }
338 |                     }
339 |                 }
340 |             }
341 | 
342 | // Join all of the member texts together, separated with commas,
343 | // and wrap them in braces.
344 | 
345 |             v = partial.length === 0 ? '{}' :
346 |                 gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
347 |                         mind + '}' : '{' + partial.join(',') + '}';
348 |             gap = mind;
349 |             return v;
350 |         }
351 |     }
352 | 
353 | // If the JSON object does not yet have a stringify method, give it one.
354 | 
355 |     if (typeof JSON.stringify !== 'function') {
356 |         JSON.stringify = function (value, replacer, space) {
357 | 
358 | // The stringify method takes a value and an optional replacer, and an optional
359 | // space parameter, and returns a JSON text. The replacer can be a function
360 | // that can replace values, or an array of strings that will select the keys.
361 | // A default replacer method can be provided. Use of the space parameter can
362 | // produce text that is more easily readable.
363 | 
364 |             var i;
365 |             gap = '';
366 |             indent = '';
367 | 
368 | // If the space parameter is a number, make an indent string containing that
369 | // many spaces.
370 | 
371 |             if (typeof space === 'number') {
372 |                 for (i = 0; i < space; i += 1) {
373 |                     indent += ' ';
374 |                 }
375 | 
376 | // If the space parameter is a string, it will be used as the indent string.
377 | 
378 |             } else if (typeof space === 'string') {
379 |                 indent = space;
380 |             }
381 | 
382 | // If there is a replacer, it must be a function or an array.
383 | // Otherwise, throw an error.
384 | 
385 |             rep = replacer;
386 |             if (replacer && typeof replacer !== 'function' &&
387 |                     (typeof replacer !== 'object' ||
388 |                      typeof replacer.length !== 'number')) {
389 |                 throw new Error('JSON.stringify');
390 |             }
391 | 
392 | // Make a fake root object containing our value under the key of ''.
393 | // Return the result of stringifying the value.
394 | 
395 |             return str('', {'': value});
396 |         };
397 |     }
398 | 
399 | 
400 | // If the JSON object does not yet have a parse method, give it one.
401 | 
402 |     if (typeof JSON.parse !== 'function') {
403 |         JSON.parse = function (text, reviver) {
404 | 
405 | // The parse method takes a text and an optional reviver function, and returns
406 | // a JavaScript value if the text is a valid JSON text.
407 | 
408 |             var j;
409 | 
410 |             function walk(holder, key) {
411 | 
412 | // The walk method is used to recursively walk the resulting structure so
413 | // that modifications can be made.
414 | 
415 |                 var k, v, value = holder[key];
416 |                 if (value && typeof value === 'object') {
417 |                     for (k in value) {
418 |                         if (Object.hasOwnProperty.call(value, k)) {
419 |                             v = walk(value, k);
420 |                             if (v !== undefined) {
421 |                                 value[k] = v;
422 |                             } else {
423 |                                 delete value[k];
424 |                             }
425 |                         }
426 |                     }
427 |                 }
428 |                 return reviver.call(holder, key, value);
429 |             }
430 | 
431 | 
432 | // Parsing happens in four stages. In the first stage, we replace certain
433 | // Unicode characters with escape sequences. JavaScript handles many characters
434 | // incorrectly, either silently deleting them, or treating them as line endings.
435 | 
436 |             text = String(text);
437 |             cx.lastIndex = 0;
438 |             if (cx.test(text)) {
439 |                 text = text.replace(cx, function (a) {
440 |                     return '\\u' +
441 |                         ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
442 |                 });
443 |             }
444 | 
445 | // In the second stage, we run the text against regular expressions that look
446 | // for non-JSON patterns. We are especially concerned with '()' and 'new'
447 | // because they can cause invocation, and '=' because it can cause mutation.
448 | // But just to be safe, we want to reject all unexpected forms.
449 | 
450 | // We split the second stage into 4 regexp operations in order to work around
451 | // crippling inefficiencies in IE's and Safari's regexp engines. First we
452 | // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
453 | // replace all simple value tokens with ']' characters. Third, we delete all
454 | // open brackets that follow a colon or comma or that begin the text. Finally,
455 | // we look to see that the remaining characters are only whitespace or ']' or
456 | // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
457 | 
458 |             if (/^[\],:{}\s]*$/
459 | .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
460 | .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
461 | .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
462 | 
463 | // In the third stage we use the eval function to compile the text into a
464 | // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
465 | // in JavaScript: it can begin a block or an object literal. We wrap the text
466 | // in parens to eliminate the ambiguity.
467 | 
468 |                 j = eval('(' + text + ')');
469 | 
470 | // In the optional fourth stage, we recursively walk the new structure, passing
471 | // each name/value pair to a reviver function for possible transformation.
472 | 
473 |                 return typeof reviver === 'function' ?
474 |                     walk({'': j}, '') : j;
475 |             }
476 | 
477 | // If the text is not JSON parseable, then a SyntaxError is thrown.
478 | 
479 |             throw new SyntaxError('JSON.parse');
480 |         };
481 |     }
482 | }());
483 | 


--------------------------------------------------------------------------------
/js/other/mobile.js:
--------------------------------------------------------------------------------
  1 | var inFullscreen = false;
  2 | var mainCanvas = null;
  3 | var fullscreenCanvas = null;
  4 | var showAsMinimal = false;
  5 | var keyZones = [
  6 |   ["right", [39]],
  7 |   ["left", [37]],
  8 |   ["up", [38]],
  9 |   ["down", [40]],
 10 |   ["a", [88, 74]],
 11 |   ["b", [90, 81, 89]],
 12 |   ["select", [16]],
 13 |   ["start", [13]]
 14 | ];
 15 | var cout = console.log.bind(console);
 16 | function startGame (blob) {
 17 |   var binaryHandle = new FileReader();
 18 |   binaryHandle.onload = function () {
 19 |     if (this.readyState === 2) {
 20 |       try {
 21 |         start(mainCanvas, this.result);
 22 |       } catch (e) {
 23 |         alert(e.message);
 24 |       }
 25 |     }
 26 |   };
 27 |   binaryHandle.readAsBinaryString(blob);
 28 | };
 29 | 
 30 | function loadViaMozActivity () {
 31 |   var activity = new MozActivity({
 32 |     name: "pick",
 33 |     data: {},
 34 |   });
 35 |   activity.onsuccess = function () {
 36 |     startGame(this.result.blob);
 37 |   };
 38 |   activity.onerror = function () {
 39 |     alert(this.error.name);
 40 |   };
 41 | };
 42 | 
 43 | function loadViaXHR () {
 44 |   var xhr = new XMLHttpRequest();
 45 |   xhr.open("GET", "insert_relative_path_to_gb_rom_here");
 46 |   xhr.responseType = "blob";
 47 |   xhr.onload = function () {
 48 |     startGame(new Blob([this.response], { type: "text/plain" }));
 49 |   };
 50 |   xhr.send();
 51 | };
 52 | 
 53 | function shim (eles) {
 54 |   function onDown (e) {
 55 |     var keyZone = e.target.dataset.keyZone;
 56 |     if (!keyZone) {
 57 |       keyZone = e.target.parentNode.dataset.keyZone;
 58 |       if (!keyZone) return;
 59 |     }
 60 |     GameBoyKeyDown(keyZone);
 61 |     navigator.vibrate(50);
 62 |   };
 63 |   function onUp (e) {
 64 |     var keyZone = e.target.dataset.keyZone;
 65 |     if (!keyZone) {
 66 |       keyZone = e.target.parentNode.dataset.keyZone;
 67 |       if (!keyZone) return;
 68 |     }
 69 |     GameBoyKeyUp(keyZone);
 70 |     navigator.vibrate(0);
 71 |   };
 72 |   eles.forEach(function (ele) {
 73 |     ele.ontouchstart = ele.onmousedown = onDown;
 74 |     ele.ontouchend = ele.onmouseup = onUp;
 75 |   });
 76 | };
 77 | 
 78 | var $ = document.getElementById.bind(document);
 79 | function registerTouchEventShim () {
 80 |   shim([
 81 |     $("a_button_group"),
 82 |     $("b_button_group"),
 83 |     $("arrow_up"),
 84 |     $("arrow_down"),
 85 |     $("arrow_right"),
 86 |     $("arrow_left"),
 87 |     $("select_button_group"),
 88 |     $("start_button_group")
 89 |   ]);
 90 | };
 91 | 
 92 | var gameBoyColors = ["#33B678", "#FFDC2B", "#F61300", "#0356F2"];
 93 | function pickRandomColor () {
 94 |   var nintendo = $("nintendo");
 95 |   $("gameboy_shell").style.backgroundColor =
 96 |     $("on_off").style.color =
 97 |     nintendo.style.borderColor =
 98 |     nintendo.style.color =
 99 |     gameBoyColors[(gameBoyColors.length * Math.random()) | 0];
100 | };
101 | 
102 | function windowingInitialize() {
103 | 	cout("windowingInitialize() called.", 0);
104 |   pickRandomColor();
105 | 	mainCanvas = document.getElementById("mainCanvas");
106 |   registerTouchEventShim();
107 |   window.onunload = autoSave;
108 |   ("MozActivity" in window ? loadViaMozActivity : loadViaXHR)();
109 | }
110 | var DEBUG_MESSAGES = false;
111 | var DEBUG_WINDOWING = false;
112 | window.addEventListener("DOMContentLoaded", windowingInitialize);
113 | function registerGUIEvents() {
114 | 	cout("In registerGUIEvents() : Registering GUI Events.", -1);
115 | 	addEvent("click", document.getElementById("terminal_clear_button"), clear_terminal);
116 | 	addEvent("click", document.getElementById("local_storage_list_refresh_button"), refreshStorageListing);
117 | 	addEvent("click", document.getElementById("terminal_close_button"), function () { windowStacks[1].hide() });
118 | 	addEvent("click", document.getElementById("about_close_button"), function () { windowStacks[2].hide() });
119 | 	addEvent("click", document.getElementById("settings_close_button"), function () { windowStacks[3].hide() });
120 | 	addEvent("click", document.getElementById("input_select_close_button"), function () { windowStacks[4].hide() });
121 | 	addEvent("click", document.getElementById("instructions_close_button"), function () { windowStacks[5].hide() });
122 | 	addEvent("click", document.getElementById("local_storage_list_close_button"), function () { windowStacks[7].hide() });
123 | 	addEvent("click", document.getElementById("local_storage_popup_close_button"), function () { windowStacks[6].hide() });
124 | 	addEvent("click", document.getElementById("save_importer_close_button"), function () { windowStacks[9].hide() });
125 | 	addEvent("click", document.getElementById("freeze_list_close_button"), function () { windowStacks[8].hide() });
126 | 	addEvent("click", document.getElementById("GameBoy_about_menu"), function () { windowStacks[2].show() });
127 | 	addEvent("click", document.getElementById("GameBoy_settings_menu"), function () { windowStacks[3].show() });
128 | 	addEvent("click", document.getElementById("local_storage_list_menu"), function () { refreshStorageListing(); windowStacks[7].show(); });
129 | 	addEvent("click", document.getElementById("freeze_list_menu"), function () { refreshFreezeListing(); windowStacks[8].show(); });
130 | 	addEvent("click", document.getElementById("view_importer"), function () { windowStacks[9].show() });
131 | 	addEvent("keydown", document, keyDown);
132 | 	addEvent("keyup", document,  function (event) {
133 | 		if (event.keyCode == 27) {
134 | 			//Fullscreen on/off
135 | 			fullscreenPlayer();
136 | 		}
137 | 		else {
138 | 			//Control keys / other
139 | 			keyUp(event);
140 | 		}
141 | 	});
142 | 	addEvent("MozOrientation", window, GameBoyGyroSignalHandler);
143 | 	addEvent("deviceorientation", window, GameBoyGyroSignalHandler);
144 | 	new popupMenu(document.getElementById("GameBoy_file_menu"), document.getElementById("GameBoy_file_popup"));
145 | 	addEvent("click", document.getElementById("data_uri_clicker"), function () {
146 | 		var datauri = prompt("Please input the ROM image's Base 64 Encoded Text:", "");
147 | 		if (datauri != null && datauri.length > 0) {
148 | 			try {
149 | 				cout(Math.floor(datauri.length * 3 / 4) + " bytes of data submitted by form (text length of " + datauri.length + ").", 0);
150 | 				initPlayer();
151 | 				start(mainCanvas, base64_decode(datauri));
152 | 			}
153 | 			catch (error) {
154 | 				alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
155 | 			}
156 | 		}
157 | 	});
158 | 	addEvent("click", document.getElementById("set_volume"), function () {
159 | 		if (GameBoyEmulatorInitialized()) {
160 | 			var volume = prompt("Set the volume here:", "1.0");
161 | 			if (volume != null && volume.length > 0) {
162 | 				settings[3] = Math.min(Math.max(parseFloat(volume), 0), 1);
163 | 				gameboy.changeVolume();
164 | 			}
165 | 		}
166 | 	});
167 | 	addEvent("click", document.getElementById("set_speed"), function () {
168 | 		if (GameBoyEmulatorInitialized()) {
169 | 			var speed = prompt("Set the emulator speed here:", "1.0");
170 | 			if (speed != null && speed.length > 0) {
171 | 				gameboy.setSpeed(Math.max(parseFloat(speed), 0.001));
172 | 			}
173 | 		}
174 | 	});
175 | 	addEvent("click", document.getElementById("internal_file_clicker"), function () {
176 | 		var file_opener = document.getElementById("local_file_open");
177 | 		windowStacks[4].show();
178 | 		file_opener.click();
179 | 	});
180 | 	addEvent("blur", document.getElementById("input_select"), function () {
181 | 		windowStacks[4].hide();
182 | 	});
183 | 	addEvent("change", document.getElementById("local_file_open"), function () {
184 | 		windowStacks[4].hide();
185 | 		if (typeof this.files != "undefined") {
186 | 			try {
187 | 				if (this.files.length >= 1) {
188 | 					cout("Reading the local file \"" + this.files[0].name + "\"", 0);
189 | 					try {
190 | 						//Gecko 1.9.2+ (Standard Method)
191 | 						var binaryHandle = new FileReader();
192 | 						binaryHandle.onload = function () {
193 | 							if (this.readyState == 2) {
194 | 								cout("file loaded.", 0);
195 | 								try {
196 | 									initPlayer();
197 | 									start(mainCanvas, this.result);
198 | 								}
199 | 								catch (error) {
200 | 									alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
201 | 								}
202 | 							}
203 | 							else {
204 | 								cout("loading file, please wait...", 0);
205 | 							}
206 | 						}
207 | 						binaryHandle.readAsBinaryString(this.files[this.files.length - 1]);
208 | 					}
209 | 					catch (error) {
210 | 						cout("Browser does not support the FileReader object, falling back to the non-standard File object access,", 2);
211 | 						//Gecko 1.9.0, 1.9.1 (Non-Standard Method)
212 | 						var romImageString = this.files[this.files.length - 1].getAsBinary();
213 | 						try {
214 | 							initPlayer();
215 | 							start(mainCanvas, romImageString);
216 | 						}
217 | 						catch (error) {
218 | 							alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
219 | 						}
220 | 						
221 | 					}
222 | 				}
223 | 				else {
224 | 					cout("Incorrect number of files selected for local loading.", 1);
225 | 				}
226 | 			}
227 | 			catch (error) {
228 | 				cout("Could not load in a locally stored ROM file.", 2);
229 | 			}
230 | 		}
231 | 		else {
232 | 			cout("could not find the handle on the file to open.", 2);
233 | 		}
234 | 	});
235 | 	addEvent("change", document.getElementById("save_open"), function () {
236 | 		windowStacks[9].hide();
237 | 		if (typeof this.files != "undefined") {
238 | 			try {
239 | 				if (this.files.length >= 1) {
240 | 					cout("Reading the local file \"" + this.files[0].name + "\" for importing.", 0);
241 | 					try {
242 | 						//Gecko 1.9.2+ (Standard Method)
243 | 						var binaryHandle = new FileReader();
244 | 						binaryHandle.onload = function () {
245 | 							if (this.readyState == 2) {
246 | 								cout("file imported.", 0);
247 | 								try {
248 | 									import_save(this.result);
249 | 									refreshStorageListing();
250 | 								}
251 | 								catch (error) {
252 | 									alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
253 | 								}
254 | 							}
255 | 							else {
256 | 								cout("importing file, please wait...", 0);
257 | 							}
258 | 						}
259 | 						binaryHandle.readAsBinaryString(this.files[this.files.length - 1]);
260 | 					}
261 | 					catch (error) {
262 | 						cout("Browser does not support the FileReader object, falling back to the non-standard File object access,", 2);
263 | 						//Gecko 1.9.0, 1.9.1 (Non-Standard Method)
264 | 						var romImageString = this.files[this.files.length - 1].getAsBinary();
265 | 						try {
266 | 							import_save(romImageString);
267 | 							refreshStorageListing();
268 | 						}
269 | 						catch (error) {
270 | 							alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
271 | 						}
272 | 						
273 | 					}
274 | 				}
275 | 				else {
276 | 					cout("Incorrect number of files selected for local loading.", 1);
277 | 				}
278 | 			}
279 | 			catch (error) {
280 | 				cout("Could not load in a locally stored ROM file.", 2);
281 | 			}
282 | 		}
283 | 		else {
284 | 			cout("could not find the handle on the file to open.", 2);
285 | 		}
286 | 	});
287 | 	addEvent("click", document.getElementById("restart_cpu_clicker"), function () {
288 | 		if (GameBoyEmulatorInitialized()) {
289 | 			try {
290 | 				if (!gameboy.fromSaveState) {
291 | 					initPlayer();
292 | 					start(mainCanvas, gameboy.getROMImage());
293 | 				}
294 | 				else {
295 | 					initPlayer();
296 | 					openState(gameboy.savedStateFileName, mainCanvas);
297 | 				}
298 | 			}
299 | 			catch (error) {
300 | 				alert(error.message + " file: " + error.fileName + " line: " + error.lineNumber);
301 | 			}
302 | 		}
303 | 		else {
304 | 			cout("Could not restart, as a previous emulation session could not be found.", 1);
305 | 		}
306 | 	});
307 | 	addEvent("click", document.getElementById("run_cpu_clicker"), function () {
308 | 		run();
309 | 	});
310 | 	addEvent("click", document.getElementById("kill_cpu_clicker"), function () {
311 | 		pause();
312 | 	});
313 | 	addEvent("click", document.getElementById("save_state_clicker"), function () {
314 | 		save();
315 | 	});
316 | 	addEvent("click", document.getElementById("save_SRAM_state_clicker"), function () {
317 | 		saveSRAM();
318 | 	});
319 | 	addEvent("click", document.getElementById("enable_sound"), function () {
320 | 		settings[0] = document.getElementById("enable_sound").checked;
321 | 		if (GameBoyEmulatorInitialized()) {
322 | 			gameboy.initSound();
323 | 		}
324 | 	});
325 | 	addEvent("click", document.getElementById("disable_colors"), function () {
326 | 		settings[2] = document.getElementById("disable_colors").checked;
327 | 	});
328 | 	addEvent("click", document.getElementById("rom_only_override"), function () {
329 | 		settings[9] = document.getElementById("rom_only_override").checked;
330 | 	});
331 | 	addEvent("click", document.getElementById("mbc_enable_override"), function () {
332 | 		settings[10] = document.getElementById("mbc_enable_override").checked;
333 | 	});
334 | 	addEvent("click", document.getElementById("enable_gbc_bios"), function () {
335 | 		settings[1] = document.getElementById("enable_gbc_bios").checked;
336 | 	});
337 | 	addEvent("click", document.getElementById("enable_colorization"), function () {
338 | 		settings[4] = document.getElementById("enable_colorization").checked;
339 | 	});
340 | 	addEvent("click", document.getElementById("do_minimal"), function () {
341 | 		showAsMinimal = document.getElementById("do_minimal").checked;
342 | 		fullscreenCanvas.className = (showAsMinimal) ? "minimum" : "maximum";
343 | 	});
344 | 	addEvent("click", document.getElementById("software_resizing"), function () {
345 | 		settings[12] = document.getElementById("software_resizing").checked;
346 | 		if (GameBoyEmulatorInitialized()) {
347 | 			gameboy.initLCD();
348 | 		}
349 | 	});
350 | 	addEvent("click", document.getElementById("typed_arrays_disallow"), function () {
351 | 		settings[5] = document.getElementById("typed_arrays_disallow").checked;
352 | 	});
353 | 	addEvent("click", document.getElementById("gb_boot_rom_utilized"), function () {
354 | 		settings[11] = document.getElementById("gb_boot_rom_utilized").checked;
355 | 	});
356 | 	addEvent("click", document.getElementById("resize_smoothing"), function () {
357 | 		settings[13] = document.getElementById("resize_smoothing").checked;
358 | 		if (GameBoyEmulatorInitialized()) {
359 | 			gameboy.initLCD();
360 | 		}
361 | 	});
362 |     addEvent("click", document.getElementById("channel1"), function () {
363 |         settings[14][0] = document.getElementById("channel1").checked;
364 |     });
365 |     addEvent("click", document.getElementById("channel2"), function () {
366 |         settings[14][1] = document.getElementById("channel2").checked;
367 |     });
368 |     addEvent("click", document.getElementById("channel3"), function () {
369 |         settings[14][2] = document.getElementById("channel3").checked;
370 |     });
371 |     addEvent("click", document.getElementById("channel4"), function () {
372 |         settings[14][3] = document.getElementById("channel4").checked;
373 |     });
374 | 	addEvent("click", document.getElementById("view_fullscreen"), fullscreenPlayer);
375 | 	new popupMenu(document.getElementById("GameBoy_view_menu"), document.getElementById("GameBoy_view_popup"));
376 | 	addEvent("click", document.getElementById("view_terminal"), function () { windowStacks[1].show() });
377 | 	addEvent("click", document.getElementById("view_instructions"), function () { windowStacks[5].show() });
378 | 	addEvent("mouseup", document.getElementById("gfx"), initNewCanvasSize);
379 | 	addEvent("resize", window, initNewCanvasSize);
380 | 	addEvent("unload", window, function () {
381 | 		autoSave();
382 | 	});
383 | }
384 | function keyDown(event) {
385 | 	var keyCode = event.keyCode;
386 | 	var keyMapLength = keyZones.length;
387 | 	for (var keyMapIndex = 0; keyMapIndex < keyMapLength; ++keyMapIndex) {
388 | 		var keyCheck = keyZones[keyMapIndex];
389 | 		var keysMapped = keyCheck[1];
390 | 		var keysTotal = keysMapped.length;
391 | 		for (var index = 0; index < keysTotal; ++index) {
392 | 			if (keysMapped[index] == keyCode) {
393 | 				GameBoyKeyDown(keyCheck[0]);
394 | 				try {
395 | 					event.preventDefault();
396 | 				}
397 | 				catch (error) { }
398 | 			}
399 | 		}
400 | 	}
401 | }
402 | function keyUp(event) {
403 | 	var keyCode = event.keyCode;
404 | 	var keyMapLength = keyZones.length;
405 | 	for (var keyMapIndex = 0; keyMapIndex < keyMapLength; ++keyMapIndex) {
406 | 		var keyCheck = keyZones[keyMapIndex];
407 | 		var keysMapped = keyCheck[1];
408 | 		var keysTotal = keysMapped.length;
409 | 		for (var index = 0; index < keysTotal; ++index) {
410 | 			if (keysMapped[index] == keyCode) {
411 | 				GameBoyKeyUp(keyCheck[0]);
412 | 				try {
413 | 					event.preventDefault();
414 | 				}
415 | 				catch (error) { }
416 | 			}
417 | 		}
418 | 	}
419 | }
420 | function initPlayer() {
421 | 	document.getElementById("title").style.display = "none";
422 | 	document.getElementById("port_title").style.display = "none";
423 | 	document.getElementById("fullscreenContainer").style.display = "none";
424 | }
425 | function fullscreenPlayer() {
426 | 	if (GameBoyEmulatorInitialized()) {
427 | 		if (!inFullscreen) {
428 | 			gameboy.canvas = fullscreenCanvas;
429 | 			fullscreenCanvas.className = (showAsMinimal) ? "minimum" : "maximum";
430 | 			document.getElementById("fullscreenContainer").style.display = "block";
431 | 			windowStacks[0].hide();
432 | 		}
433 | 		else {
434 | 			gameboy.canvas = mainCanvas;
435 | 			document.getElementById("fullscreenContainer").style.display = "none";
436 | 			windowStacks[0].show();
437 | 		}
438 | 		gameboy.initLCD();
439 | 		inFullscreen = !inFullscreen;
440 | 	}
441 | 	else {
442 | 		cout("Cannot go into fullscreen mode.", 2);
443 | 	}
444 | }
445 | function runFreeze(keyName) {
446 | 	try {
447 | 		windowStacks[8].hide();
448 | 		initPlayer();
449 | 		openState(keyName, mainCanvas);
450 | 	}
451 | 	catch (error) {
452 | 		cout("A problem with attempting to open the selected save state occurred.", 2);
453 | 	}
454 | }
455 | //Wrapper for localStorage getItem, so that data can be retrieved in various types.
456 | function findValue(key) {
457 | 	try {
458 | 		if (window.localStorage.getItem(key) != null) {
459 | 			return JSON.parse(window.localStorage.getItem(key));
460 | 		}
461 | 	}
462 | 	catch (error) {
463 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
464 | 		if (window.globalStorage[location.hostname].getItem(key) != null) {
465 | 			return JSON.parse(window.globalStorage[location.hostname].getItem(key));
466 | 		}
467 | 	}
468 | 	return null;
469 | }
470 | //Wrapper for localStorage setItem, so that data can be set in various types.
471 | function setValue(key, value) {
472 | 	try {
473 | 		window.localStorage.setItem(key, JSON.stringify(value));
474 | 	}
475 | 	catch (error) {
476 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
477 | 		window.globalStorage[location.hostname].setItem(key, JSON.stringify(value));
478 | 	}
479 | }
480 | //Wrapper for localStorage removeItem, so that data can be set in various types.
481 | function deleteValue(key) {
482 | 	try {
483 | 		window.localStorage.removeItem(key);
484 | 	}
485 | 	catch (error) {
486 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
487 | 		window.globalStorage[location.hostname].removeItem(key);
488 | 	}
489 | }
490 | function outputLocalStorageLink(keyName, dataFound, downloadName) {
491 | 	return generateDownloadLink("data:application/octet-stream;base64," + dataFound, keyName, downloadName);
492 | }
493 | function refreshFreezeListing() {
494 | 	var storageListMasterDivSub = document.getElementById("freezeListingMasterContainerSub");
495 | 	var storageListMasterDiv = document.getElementById("freezeListingMasterContainer");
496 | 	storageListMasterDiv.removeChild(storageListMasterDivSub);
497 | 	storageListMasterDivSub = document.createElement("div");
498 | 	storageListMasterDivSub.id = "freezeListingMasterContainerSub";
499 | 	var keys = getLocalStorageKeys();
500 | 	while (keys.length > 0) {
501 | 		key = keys.shift();
502 | 		if (key.substring(0, 7) == "FREEZE_") {
503 | 			storageListMasterDivSub.appendChild(outputFreezeStateRequestLink(key));
504 | 		}
505 | 	}
506 | 	storageListMasterDiv.appendChild(storageListMasterDivSub);
507 | }
508 | function outputFreezeStateRequestLink(keyName) {
509 | 	var linkNode = generateLink("javascript:runFreeze(\"" + keyName + "\")", keyName);
510 | 	var storageContainerDiv = document.createElement("div");
511 | 	storageContainerDiv.className = "storageListingContainer";
512 | 	storageContainerDiv.appendChild(linkNode)
513 | 	return storageContainerDiv;
514 | }
515 | function refreshStorageListing() {
516 | 	var storageListMasterDivSub = document.getElementById("storageListingMasterContainerSub");
517 | 	var storageListMasterDiv = document.getElementById("storageListingMasterContainer");
518 | 	storageListMasterDiv.removeChild(storageListMasterDivSub);
519 | 	storageListMasterDivSub = document.createElement("div");
520 | 	storageListMasterDivSub.id = "storageListingMasterContainerSub";
521 | 	var keys = getLocalStorageKeys();
522 | 	var blobPairs = [];
523 | 	for (var index = 0; index < keys.length; ++index) {
524 | 		blobPairs[index] = getBlobPreEncoded(keys[index]);
525 | 		storageListMasterDivSub.appendChild(outputLocalStorageRequestLink(keys[index]));
526 | 	}
527 | 	storageListMasterDiv.appendChild(storageListMasterDivSub);
528 | 	var linkToManipulate = document.getElementById("download_local_storage_dba");
529 | 	linkToManipulate.href = "data:application/octet-stream;base64," + base64(generateMultiBlob(blobPairs));
530 | 	linkToManipulate.download = "gameboy_color_saves.export";
531 | }
532 | function getBlobPreEncoded(keyName) {
533 |   alert("getBlobPreEncoded");
534 | 	if (keyName.substring(0, 9) == "B64_SRAM_") {
535 | 		return [keyName.substring(4), base64_decode(findValue(keyName))];
536 | 	}
537 | 	else if (keyName.substring(0, 5) == "SRAM_") {
538 | 		return [keyName, convertToBinary(findValue(keyName))];
539 | 	}
540 | 	else {
541 | 		return [keyName, JSON.stringify(findValue(keyName))];
542 | 	}
543 | }
544 | function outputLocalStorageRequestLink(keyName) {
545 | 	var linkNode = generateLink("javascript:popupStorageDialog(\"" + keyName + "\")", keyName);
546 | 	var storageContainerDiv = document.createElement("div");
547 | 	storageContainerDiv.className = "storageListingContainer";
548 | 	storageContainerDiv.appendChild(linkNode)
549 | 	return storageContainerDiv;
550 | }
551 | function popupStorageDialog(keyName) {
552 | 	var subContainer = document.getElementById("storagePopupMasterContainer");
553 | 	var parentContainer = document.getElementById("storagePopupMasterParent");
554 | 	parentContainer.removeChild(subContainer);
555 | 	subContainer = document.createElement("div");
556 | 	subContainer.id = "storagePopupMasterContainer";
557 | 	parentContainer.appendChild(subContainer);
558 | 	var downloadDiv = document.createElement("div");
559 | 	downloadDiv.id = "storagePopupDownload";
560 | 	if (keyName.substring(0, 9) == "B64_SRAM_") {
561 | 		var downloadDiv2 = document.createElement("div");
562 | 		downloadDiv2.id = "storagePopupDownloadRAW";
563 | 		downloadDiv2.appendChild(outputLocalStorageLink("Download RAW save data.", findValue(keyName), keyName));
564 | 		subContainer.appendChild(downloadDiv2);
565 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName.substring(4), base64_decode(findValue(keyName)))), keyName));
566 | 	}
567 | 	else if (keyName.substring(0, 5) == "SRAM_") {
568 | 		var downloadDiv2 = document.createElement("div");
569 | 		downloadDiv2.id = "storagePopupDownloadRAW";
570 | 		downloadDiv2.appendChild(outputLocalStorageLink("Download RAW save data.", base64(convertToBinary(findValue(keyName))), keyName));
571 | 		subContainer.appendChild(downloadDiv2);
572 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName, convertToBinary(findValue(keyName)))), keyName));
573 | 	}
574 | 	else {
575 | 		downloadDiv.appendChild(outputLocalStorageLink("Download in import compatible format.", base64(generateBlob(keyName, JSON.stringify(findValue(keyName)))), keyName));
576 | 	}
577 | 	var deleteLink = generateLink("javascript:deleteStorageSlot(\"" + keyName + "\")", "Delete data item from HTML5 local storage.");
578 | 	deleteLink.id = "storagePopupDelete";
579 | 	subContainer.appendChild(downloadDiv);
580 | 	subContainer.appendChild(deleteLink);
581 | 	windowStacks[6].show();
582 | }
583 | function convertToBinary(jsArray) {
584 | 	var length = jsArray.length;
585 | 	var binString = "";
586 | 	for (var indexBin = 0; indexBin < length; indexBin++) {
587 | 		binString += String.fromCharCode(jsArray[indexBin]);
588 | 	}
589 | 	return binString;
590 | }
591 | function deleteStorageSlot(keyName) {
592 | 	deleteValue(keyName);
593 | 	windowStacks[6].hide();
594 | 	refreshStorageListing();
595 | }
596 | function generateLink(address, textData) {
597 | 	var link = document.createElement("a");
598 | 	link.href = address;
599 | 	link.appendChild(document.createTextNode(textData));
600 | 	return link;
601 | }
602 | function generateDownloadLink(address, textData, keyName) {
603 | 	var link = generateLink(address, textData);
604 | 	link.download = keyName + ".sav";
605 | 	return link;
606 | }
607 | function checkStorageLength() {
608 | 	try {
609 | 		return window.localStorage.length;
610 | 	}
611 | 	catch (error) {
612 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
613 | 		return window.globalStorage[location.hostname].length;
614 | 	}
615 | }
616 | function getLocalStorageKeys() {
617 |   alert("getLocalStorageKeys");
618 | 	var storageLength = checkStorageLength();
619 | 	var keysFound = [];
620 | 	var index = 0;
621 | 	var nextKey = null;
622 | 	while (index < storageLength) {
623 | 		nextKey = findKey(index++);
624 | 		if (nextKey !== null && nextKey.length > 0) {
625 | 			if (nextKey.substring(0, 5) == "SRAM_" || nextKey.substring(0, 9) == "B64_SRAM_" || nextKey.substring(0, 7) == "FREEZE_" || nextKey.substring(0, 4) == "RTC_") {
626 | 				keysFound.push(nextKey);
627 | 			}
628 | 		}
629 | 		else {
630 | 			break;
631 | 		}
632 | 	}
633 | 	return keysFound;
634 | }
635 | function findKey(keyNum) {
636 | 	try {
637 | 		return window.localStorage.key(keyNum);
638 | 	}
639 | 	catch (error) {
640 | 		//An older Gecko 1.8.1/1.9.0 method of storage (Deprecated due to the obvious security hole):
641 | 		return window.globalStorage[location.hostname].key(keyNum);
642 | 	}
643 | 	return null;
644 | }
645 | //Some wrappers and extensions for non-DOM3 browsers:
646 | function isDescendantOf(ParentElement, toCheck) {
647 | 	if (!ParentElement || !toCheck) {
648 | 		return false;
649 | 	}
650 | 	//Verify an object as either a direct or indirect child to another object.
651 | 	function traverseTree(domElement) {
652 | 		while (domElement != null) {
653 | 			if (domElement.nodeType == 1) {
654 | 				if (isSameNode(domElement, toCheck)) {
655 | 					return true;
656 | 				}
657 | 				if (hasChildNodes(domElement)) {
658 | 					if (traverseTree(domElement.firstChild)) {
659 | 						return true;
660 | 					}
661 | 				}
662 | 			}
663 | 			domElement = domElement.nextSibling;
664 | 		}
665 | 		return false;
666 | 	}
667 | 	return traverseTree(ParentElement.firstChild);
668 | }
669 | function hasChildNodes(oElement) {
670 | 	return (typeof oElement.hasChildNodes == "function") ? oElement.hasChildNodes() : ((oElement.firstChild != null) ? true : false);
671 | }
672 | function isSameNode(oCheck1, oCheck2) {
673 | 	return (typeof oCheck1.isSameNode == "function") ? oCheck1.isSameNode(oCheck2) : (oCheck1 === oCheck2);
674 | }
675 | function pageXCoord(event) {
676 | 	if (typeof event.pageX == "undefined") {
677 | 		return event.clientX + document.documentElement.scrollLeft;
678 | 	}
679 | 	return event.pageX;
680 | }
681 | function pageYCoord(event) {
682 | 	if (typeof event.pageY == "undefined") {
683 | 		return event.clientY + document.documentElement.scrollTop;
684 | 	}
685 | 	return event.pageY;
686 | }
687 | function mouseLeaveVerify(oElement, event) {
688 | 	//Hook target element with onmouseout and use this function to verify onmouseleave.
689 | 	return isDescendantOf(oElement, (typeof event.target != "undefined") ? event.target : event.srcElement) && !isDescendantOf(oElement, (typeof event.relatedTarget != "undefined") ? event.relatedTarget : event.toElement);
690 | }
691 | function mouseEnterVerify(oElement, event) {
692 | 	//Hook target element with onmouseover and use this function to verify onmouseenter.
693 | 	return !isDescendantOf(oElement, (typeof event.target != "undefined") ? event.target : event.srcElement) && isDescendantOf(oElement, (typeof event.relatedTarget != "undefined") ? event.relatedTarget : event.fromElement);
694 | }
695 | function addEvent(sEvent, oElement, fListener) {
696 | 	try {	
697 | 		oElement.addEventListener(sEvent, fListener, false);
698 | 		cout("In addEvent() : Standard addEventListener() called to add a(n) \"" + sEvent + "\" event.", -1);
699 | 	}
700 | 	catch (error) {
701 | 		oElement.attachEvent("on" + sEvent, fListener);	//Pity for IE.
702 | 		cout("In addEvent() : Nonstandard attachEvent() called to add an \"on" + sEvent + "\" event.", -1);
703 | 	}
704 | }
705 | function removeEvent(sEvent, oElement, fListener) {
706 | 	try {	
707 | 		oElement.removeEventListener(sEvent, fListener, false);
708 | 		cout("In removeEvent() : Standard removeEventListener() called to remove a(n) \"" + sEvent + "\" event.", -1);
709 | 	}
710 | 	catch (error) {
711 | 		oElement.detachEvent("on" + sEvent, fListener);	//Pity for IE.
712 | 		cout("In removeEvent() : Nonstandard detachEvent() called to remove an \"on" + sEvent + "\" event.", -1);
713 | 	}
714 | }
715 | 


--------------------------------------------------------------------------------
/js/other/resampler.js:
--------------------------------------------------------------------------------
  1 | //JavaScript Audio Resampler (c) 2011 - Grant Galitz
  2 | function Resampler(fromSampleRate, toSampleRate, channels, outputBufferSize, noReturn) {
  3 | 	this.fromSampleRate = fromSampleRate;
  4 | 	this.toSampleRate = toSampleRate;
  5 | 	this.channels = channels | 0;
  6 | 	this.outputBufferSize = outputBufferSize;
  7 | 	this.noReturn = !!noReturn;
  8 | 	this.initialize();
  9 | }
 10 | Resampler.prototype.initialize = function () {
 11 | 	//Perform some checks:
 12 | 	if (this.fromSampleRate > 0 && this.toSampleRate > 0 && this.channels > 0) {
 13 | 		if (this.fromSampleRate == this.toSampleRate) {
 14 | 			//Setup a resampler bypass:
 15 | 			this.resampler = this.bypassResampler;		//Resampler just returns what was passed through.
 16 |             this.ratioWeight = 1;
 17 | 		}
 18 | 		else {
 19 |             this.ratioWeight = this.fromSampleRate / this.toSampleRate;
 20 | 			if (this.fromSampleRate < this.toSampleRate) {
 21 | 				/*
 22 | 					Use generic linear interpolation if upsampling,
 23 | 					as linear interpolation produces a gradient that we want
 24 | 					and works fine with two input sample points per output in this case.
 25 | 				*/
 26 | 				this.compileLinearInterpolationFunction();
 27 | 				this.lastWeight = 1;
 28 | 			}
 29 | 			else {
 30 | 				/*
 31 | 					Custom resampler I wrote that doesn't skip samples
 32 | 					like standard linear interpolation in high downsampling.
 33 | 					This is more accurate than linear interpolation on downsampling.
 34 | 				*/
 35 | 				this.compileMultiTapFunction();
 36 | 				this.tailExists = false;
 37 | 				this.lastWeight = 0;
 38 | 			}
 39 | 			this.initializeBuffers();
 40 | 		}
 41 | 	}
 42 | 	else {
 43 | 		throw(new Error("Invalid settings specified for the resampler."));
 44 | 	}
 45 | }
 46 | Resampler.prototype.compileLinearInterpolationFunction = function () {
 47 | 	var toCompile = "var bufferLength = buffer.length;\
 48 | 	var outLength = this.outputBufferSize;\
 49 | 	if ((bufferLength % " + this.channels + ") == 0) {\
 50 | 		if (bufferLength > 0) {\
 51 | 			var weight = this.lastWeight;\
 52 | 			var firstWeight = 0;\
 53 | 			var secondWeight = 0;\
 54 | 			var sourceOffset = 0;\
 55 | 			var outputOffset = 0;\
 56 | 			var outputBuffer = this.outputBuffer;\
 57 | 			for (; weight < 1; weight += " + this.ratioWeight + ") {\
 58 | 				secondWeight = weight % 1;\
 59 | 				firstWeight = 1 - secondWeight;";
 60 | 	for (var channel = 0; channel < this.channels; ++channel) {
 61 | 		toCompile += "outputBuffer[outputOffset++] = (this.lastOutput[" + channel + "] * firstWeight) + (buffer[" + channel + "] * secondWeight);";
 62 | 	}
 63 | 	toCompile += "}\
 64 | 			weight -= 1;\
 65 | 			for (bufferLength -= " + this.channels + ", sourceOffset = Math.floor(weight) * " + this.channels + "; outputOffset < outLength && sourceOffset < bufferLength;) {\
 66 | 				secondWeight = weight % 1;\
 67 | 				firstWeight = 1 - secondWeight;";
 68 | 	for (var channel = 0; channel < this.channels; ++channel) {
 69 | 		toCompile += "outputBuffer[outputOffset++] = (buffer[sourceOffset" + ((channel > 0) ? (" + " + channel) : "") + "] * firstWeight) + (buffer[sourceOffset + " + (this.channels + channel) + "] * secondWeight);";
 70 | 	}
 71 | 	toCompile += "weight += " + this.ratioWeight + ";\
 72 | 				sourceOffset = Math.floor(weight) * " + this.channels + ";\
 73 | 			}";
 74 | 	for (var channel = 0; channel < this.channels; ++channel) {
 75 | 		toCompile += "this.lastOutput[" + channel + "] = buffer[sourceOffset++];";
 76 | 	}
 77 | 	toCompile += "this.lastWeight = weight % 1;\
 78 | 			return this.bufferSlice(outputOffset);\
 79 | 		}\
 80 | 		else {\
 81 | 			return (this.noReturn) ? 0 : [];\
 82 | 		}\
 83 | 	}\
 84 | 	else {\
 85 | 		throw(new Error(\"Buffer was of incorrect sample length.\"));\
 86 | 	}";
 87 | 	this.resampler = Function("buffer", toCompile);
 88 | }
 89 | Resampler.prototype.compileMultiTapFunction = function () {
 90 | 	var toCompile = "var bufferLength = buffer.length;\
 91 | 	var outLength = this.outputBufferSize;\
 92 | 	if ((bufferLength % " + this.channels + ") == 0) {\
 93 | 		if (bufferLength > 0) {\
 94 | 			var weight = 0;";
 95 | 	for (var channel = 0; channel < this.channels; ++channel) {
 96 | 		toCompile += "var output" + channel + " = 0;"
 97 | 	}
 98 | 	toCompile += "var actualPosition = 0;\
 99 | 			var amountToNext = 0;\
100 | 			var alreadyProcessedTail = !this.tailExists;\
101 | 			this.tailExists = false;\
102 | 			var outputBuffer = this.outputBuffer;\
103 | 			var outputOffset = 0;\
104 | 			var currentPosition = 0;\
105 | 			do {\
106 | 				if (alreadyProcessedTail) {\
107 | 					weight = " + this.ratioWeight + ";";
108 | 	for (channel = 0; channel < this.channels; ++channel) {
109 | 		toCompile += "output" + channel + " = 0;"
110 | 	}
111 | 	toCompile += "}\
112 | 				else {\
113 | 					weight = this.lastWeight;";
114 | 	for (channel = 0; channel < this.channels; ++channel) {
115 | 		toCompile += "output" + channel + " = this.lastOutput[" + channel + "];"
116 | 	}
117 | 	toCompile += "alreadyProcessedTail = true;\
118 | 				}\
119 | 				while (weight > 0 && actualPosition < bufferLength) {\
120 | 					amountToNext = 1 + actualPosition - currentPosition;\
121 | 					if (weight >= amountToNext) {";
122 | 	for (channel = 0; channel < this.channels; ++channel) {
123 | 		toCompile += "output" + channel + " += buffer[actualPosition++] * amountToNext;"
124 | 	}
125 | 	toCompile += "currentPosition = actualPosition;\
126 | 						weight -= amountToNext;\
127 | 					}\
128 | 					else {";
129 | 	for (channel = 0; channel < this.channels; ++channel) {
130 | 		toCompile += "output" + channel + " += buffer[actualPosition" + ((channel > 0) ? (" + " + channel) : "") + "] * weight;"
131 | 	}
132 | 	toCompile += "currentPosition += weight;\
133 | 						weight = 0;\
134 | 						break;\
135 | 					}\
136 | 				}\
137 | 				if (weight <= 0) {";
138 | 	for (channel = 0; channel < this.channels; ++channel) {
139 | 		toCompile += "outputBuffer[outputOffset++] = output" + channel + " / " + this.ratioWeight + ";"
140 | 	}
141 | 	toCompile += "}\
142 | 				else {\
143 | 					this.lastWeight = weight;";
144 | 	for (channel = 0; channel < this.channels; ++channel) {
145 | 		toCompile += "this.lastOutput[" + channel + "] = output" + channel + ";"
146 | 	}
147 | 	toCompile += "this.tailExists = true;\
148 | 					break;\
149 | 				}\
150 | 			} while (actualPosition < bufferLength && outputOffset < outLength);\
151 | 			return this.bufferSlice(outputOffset);\
152 | 		}\
153 | 		else {\
154 | 			return (this.noReturn) ? 0 : [];\
155 | 		}\
156 | 	}\
157 | 	else {\
158 | 		throw(new Error(\"Buffer was of incorrect sample length.\"));\
159 | 	}";
160 | 	this.resampler = Function("buffer", toCompile);
161 | }
162 | Resampler.prototype.bypassResampler = function (buffer) {
163 | 	if (this.noReturn) {
164 | 		//Set the buffer passed as our own, as we don't need to resample it:
165 | 		this.outputBuffer = buffer;
166 | 		return buffer.length;
167 | 	}
168 | 	else {
169 | 		//Just return the buffer passsed:
170 | 		return buffer;
171 | 	}
172 | }
173 | Resampler.prototype.bufferSlice = function (sliceAmount) {
174 | 	if (this.noReturn) {
175 | 		//If we're going to access the properties directly from this object:
176 | 		return sliceAmount;
177 | 	}
178 | 	else {
179 | 		//Typed array and normal array buffer section referencing:
180 | 		try {
181 | 			return this.outputBuffer.subarray(0, sliceAmount);
182 | 		}
183 | 		catch (error) {
184 | 			try {
185 | 				//Regular array pass:
186 | 				this.outputBuffer.length = sliceAmount;
187 | 				return this.outputBuffer;
188 | 			}
189 | 			catch (error) {
190 | 				//Nightly Firefox 4 used to have the subarray function named as slice:
191 | 				return this.outputBuffer.slice(0, sliceAmount);
192 | 			}
193 | 		}
194 | 	}
195 | }
196 | Resampler.prototype.initializeBuffers = function () {
197 | 	//Initialize the internal buffer:
198 | 	try {
199 | 		this.outputBuffer = new Float32Array(this.outputBufferSize);
200 | 		this.lastOutput = new Float32Array(this.channels);
201 | 	}
202 | 	catch (error) {
203 | 		this.outputBuffer = [];
204 | 		this.lastOutput = [];
205 | 	}
206 | }


--------------------------------------------------------------------------------
/js/other/resize.js:
--------------------------------------------------------------------------------
  1 | //JavaScript Image Resizer (c) 2012 - Grant Galitz
  2 | var scripts = document.getElementsByTagName("script");
  3 | var sourceOfWorker = scripts[scripts.length-1].src;
  4 | function Resize(widthOriginal, heightOriginal, targetWidth, targetHeight, blendAlpha, interpolationPass, useWebWorker, resizeCallback) {
  5 | 	this.widthOriginal = Math.abs(parseInt(widthOriginal) || 0);
  6 | 	this.heightOriginal = Math.abs(parseInt(heightOriginal) || 0);
  7 | 	this.targetWidth = Math.abs(parseInt(targetWidth) || 0);
  8 | 	this.targetHeight = Math.abs(parseInt(targetHeight) || 0);
  9 | 	this.colorChannels = (!!blendAlpha) ? 4 : 3;
 10 | 	this.interpolationPass = !!interpolationPass;
 11 | 	this.useWebWorker = !!useWebWorker;
 12 | 	this.resizeCallback = (typeof resizeCallback == "function") ? resizeCallback : function (returnedArray) {};
 13 | 	this.targetWidthMultipliedByChannels = this.targetWidth * this.colorChannels;
 14 | 	this.originalWidthMultipliedByChannels = this.widthOriginal * this.colorChannels;
 15 | 	this.originalHeightMultipliedByChannels = this.heightOriginal * this.colorChannels;
 16 | 	this.widthPassResultSize = this.targetWidthMultipliedByChannels * this.heightOriginal;
 17 | 	this.finalResultSize = this.targetWidthMultipliedByChannels * this.targetHeight;
 18 | 	this.initialize();
 19 | }
 20 | Resize.prototype.initialize = function () {
 21 | 	//Perform some checks:
 22 | 	if (this.widthOriginal > 0 && this.heightOriginal > 0 && this.targetWidth > 0 && this.targetHeight > 0) {
 23 | 		if (this.useWebWorker) {
 24 | 			this.useWebWorker = (this.widthOriginal != this.targetWidth || this.heightOriginal != this.targetHeight);
 25 | 			if (this.useWebWorker) {
 26 | 				this.configureWorker();
 27 | 			}
 28 | 		}
 29 | 		if (!this.useWebWorker) {
 30 | 			this.configurePasses();
 31 | 		}
 32 | 	}
 33 | 	else {
 34 | 		throw(new Error("Invalid settings specified for the resizer."));
 35 | 	}
 36 | }
 37 | Resize.prototype.configureWorker = function () {
 38 | 	try {
 39 | 		var parentObj = this;
 40 | 		this.worker = new Worker(sourceOfWorker.substring(0, sourceOfWorker.length - 3) + "Worker.js");
 41 | 		this.worker.onmessage = function (event) {
 42 | 			parentObj.heightBuffer = event.data;
 43 | 			parentObj.resizeCallback(parentObj.heightBuffer);
 44 | 		}
 45 | 		this.worker.postMessage(["setup", this.widthOriginal, this.heightOriginal, this.targetWidth, this.targetHeight, this.colorChannels, this.interpolationPass]);
 46 | 	}
 47 | 	catch (error) {
 48 | 		this.useWebWorker = false;
 49 | 	}
 50 | }
 51 | Resize.prototype.configurePasses = function () {
 52 | 	if (this.widthOriginal == this.targetWidth) {
 53 | 		//Bypass the width resizer pass:
 54 | 		this.resizeWidth = this.bypassResizer;
 55 | 	}
 56 | 	else {
 57 | 		//Setup the width resizer pass:
 58 | 		this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
 59 | 		if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
 60 | 			this.initializeFirstPassBuffers(true);
 61 | 			this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthInterpolatedRGBA : this.resizeWidthInterpolatedRGB;
 62 | 		}
 63 | 		else {
 64 | 			this.initializeFirstPassBuffers(false);
 65 | 			this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthRGBA : this.resizeWidthRGB;
 66 | 		}
 67 | 	}
 68 | 	if (this.heightOriginal == this.targetHeight) {
 69 | 		//Bypass the height resizer pass:
 70 | 		this.resizeHeight = this.bypassResizer;
 71 | 	}
 72 | 	else {	
 73 | 		//Setup the height resizer pass:
 74 | 		this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
 75 | 		if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
 76 | 			this.initializeSecondPassBuffers(true);
 77 | 			this.resizeHeight = this.resizeHeightInterpolated;
 78 | 		}
 79 | 		else {
 80 | 			this.initializeSecondPassBuffers(false);
 81 | 			this.resizeHeight = (this.colorChannels == 4) ? this.resizeHeightRGBA : this.resizeHeightRGB;
 82 | 		}
 83 | 	}
 84 | }
 85 | Resize.prototype.resizeWidthRGB = function (buffer) {
 86 | 	var ratioWeight = this.ratioWeightWidthPass;
 87 | 	var ratioWeightDivisor = 1 / ratioWeight;
 88 | 	var weight = 0;
 89 | 	var amountToNext = 0;
 90 | 	var actualPosition = 0;
 91 | 	var currentPosition = 0;
 92 | 	var line = 0;
 93 | 	var pixelOffset = 0;
 94 | 	var outputOffset = 0;
 95 | 	var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 2;
 96 | 	var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 2;
 97 | 	var output = this.outputWidthWorkBench;
 98 | 	var outputBuffer = this.widthBuffer;
 99 | 	do {
100 | 		for (line = 0; line < this.originalHeightMultipliedByChannels;) {
101 | 			output[line++] = 0;
102 | 			output[line++] = 0;
103 | 			output[line++] = 0;
104 | 		}
105 | 		weight = ratioWeight;
106 | 		do {
107 | 			amountToNext = 1 + actualPosition - currentPosition;
108 | 			if (weight >= amountToNext) {
109 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
110 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
111 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
112 | 					output[line++] += buffer[pixelOffset] * amountToNext;
113 | 				}
114 | 				currentPosition = actualPosition = actualPosition + 3;
115 | 				weight -= amountToNext;
116 | 			}
117 | 			else {
118 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
119 | 					output[line++] += buffer[pixelOffset++] * weight;
120 | 					output[line++] += buffer[pixelOffset++] * weight;
121 | 					output[line++] += buffer[pixelOffset] * weight;
122 | 				}
123 | 				currentPosition += weight;
124 | 				break;
125 | 			}
126 | 		} while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
127 | 		for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
128 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
129 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
130 | 			outputBuffer[pixelOffset] = output[line++] * ratioWeightDivisor;
131 | 		}
132 | 		outputOffset += 3;
133 | 	} while (outputOffset < this.targetWidthMultipliedByChannels);
134 | 	return outputBuffer;
135 | }
136 | Resize.prototype.resizeWidthInterpolatedRGB = function (buffer) {
137 | 	var ratioWeight = this.ratioWeightWidthPass;
138 | 	var weight = 0;
139 | 	var finalOffset = 0;
140 | 	var pixelOffset = 0;
141 | 	var firstWeight = 0;
142 | 	var secondWeight = 0;
143 | 	var outputBuffer = this.widthBuffer;
144 | 	//Handle for only one interpolation input being valid for start calculation:
145 | 	for (var targetPosition = 0; weight < 1/3; targetPosition += 3, weight += ratioWeight) {
146 | 		for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
147 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
148 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
149 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
150 | 		}
151 | 	}
152 | 	//Adjust for overshoot of the last pass's counter:
153 | 	weight -= 1/3;
154 | 	for (var interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += 3, weight += ratioWeight) {
155 | 		//Calculate weightings:
156 | 		secondWeight = weight % 1;
157 | 		firstWeight = 1 - secondWeight;
158 | 		//Interpolate:
159 | 		for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 3; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
160 | 			outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 3] * secondWeight);
161 | 			outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
162 | 			outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
163 | 		}
164 | 	}
165 | 	//Handle for only one interpolation input being valid for end calculation:
166 | 	for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - 3; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 3) {
167 | 		for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
168 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
169 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
170 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
171 | 		}
172 | 	}
173 | 	return outputBuffer;
174 | }
175 | Resize.prototype.resizeWidthRGBA = function (buffer) {
176 | 	var ratioWeight = this.ratioWeightWidthPass;
177 | 	var ratioWeightDivisor = 1 / ratioWeight;
178 | 	var weight = 0;
179 | 	var amountToNext = 0;
180 | 	var actualPosition = 0;
181 | 	var currentPosition = 0;
182 | 	var line = 0;
183 | 	var pixelOffset = 0;
184 | 	var outputOffset = 0;
185 | 	var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 3;
186 | 	var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 3;
187 | 	var output = this.outputWidthWorkBench;
188 | 	var outputBuffer = this.widthBuffer;
189 | 	do {
190 | 		for (line = 0; line < this.originalHeightMultipliedByChannels;) {
191 | 			output[line++] = 0;
192 | 			output[line++] = 0;
193 | 			output[line++] = 0;
194 | 			output[line++] = 0;
195 | 		}
196 | 		weight = ratioWeight;
197 | 		do {
198 | 			amountToNext = 1 + actualPosition - currentPosition;
199 | 			if (weight >= amountToNext) {
200 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
201 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
202 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
203 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
204 | 					output[line++] += buffer[pixelOffset] * amountToNext;
205 | 				}
206 | 				currentPosition = actualPosition = actualPosition + 4;
207 | 				weight -= amountToNext;
208 | 			}
209 | 			else {
210 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
211 | 					output[line++] += buffer[pixelOffset++] * weight;
212 | 					output[line++] += buffer[pixelOffset++] * weight;
213 | 					output[line++] += buffer[pixelOffset++] * weight;
214 | 					output[line++] += buffer[pixelOffset] * weight;
215 | 				}
216 | 				currentPosition += weight;
217 | 				break;
218 | 			}
219 | 		} while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
220 | 		for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
221 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
222 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
223 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
224 | 			outputBuffer[pixelOffset] = output[line++] * ratioWeightDivisor;
225 | 		}
226 | 		outputOffset += 4;
227 | 	} while (outputOffset < this.targetWidthMultipliedByChannels);
228 | 	return outputBuffer;
229 | }
230 | Resize.prototype.resizeWidthInterpolatedRGBA = function (buffer) {
231 | 	var ratioWeight = this.ratioWeightWidthPass;
232 | 	var weight = 0;
233 | 	var finalOffset = 0;
234 | 	var pixelOffset = 0;
235 | 	var firstWeight = 0;
236 | 	var secondWeight = 0;
237 | 	var outputBuffer = this.widthBuffer;
238 | 	//Handle for only one interpolation input being valid for start calculation:
239 | 	for (var targetPosition = 0; weight < 1/3; targetPosition += 4, weight += ratioWeight) {
240 | 		for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
241 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
242 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
243 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
244 | 			outputBuffer[finalOffset + 3] = buffer[pixelOffset + 3];
245 | 		}
246 | 	}
247 | 	//Adjust for overshoot of the last pass's counter:
248 | 	weight -= 1/3;
249 | 	for (var interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += 4, weight += ratioWeight) {
250 | 		//Calculate weightings:
251 | 		secondWeight = weight % 1;
252 | 		firstWeight = 1 - secondWeight;
253 | 		//Interpolate:
254 | 		for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 4; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
255 | 			outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
256 | 			outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
257 | 			outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 6] * secondWeight);
258 | 			outputBuffer[finalOffset + 3] = (buffer[pixelOffset + 3] * firstWeight) + (buffer[pixelOffset + 7] * secondWeight);
259 | 		}
260 | 	}
261 | 	//Handle for only one interpolation input being valid for end calculation:
262 | 	for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - 4; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 4) {
263 | 		for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
264 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
265 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
266 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
267 | 			outputBuffer[finalOffset + 3] = buffer[pixelOffset + 3];
268 | 		}
269 | 	}
270 | 	return outputBuffer;
271 | }
272 | Resize.prototype.resizeHeightRGB = function (buffer) {
273 | 	var ratioWeight = this.ratioWeightHeightPass;
274 | 	var ratioWeightDivisor = 1 / ratioWeight;
275 | 	var weight = 0;
276 | 	var amountToNext = 0;
277 | 	var actualPosition = 0;
278 | 	var currentPosition = 0;
279 | 	var pixelOffset = 0;
280 | 	var outputOffset = 0;
281 | 	var output = this.outputHeightWorkBench;
282 | 	var outputBuffer = this.heightBuffer;
283 | 	do {
284 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
285 | 			output[pixelOffset++] = 0;
286 | 			output[pixelOffset++] = 0;
287 | 			output[pixelOffset++] = 0;
288 | 		}
289 | 		weight = ratioWeight;
290 | 		do {
291 | 			amountToNext = 1 + actualPosition - currentPosition;
292 | 			if (weight >= amountToNext) {
293 | 				for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
294 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
295 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
296 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
297 | 				}
298 | 				currentPosition = actualPosition;
299 | 				weight -= amountToNext;
300 | 			}
301 | 			else {
302 | 				for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
303 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
304 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
305 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
306 | 				}
307 | 				currentPosition += weight;
308 | 				break;
309 | 			}
310 | 		} while (weight > 0 && actualPosition < this.widthPassResultSize);
311 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
312 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
313 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
314 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
315 | 		}
316 | 	} while (outputOffset < this.finalResultSize);
317 | 	return outputBuffer;
318 | }
319 | Resize.prototype.resizeHeightInterpolated = function (buffer) {
320 | 	var ratioWeight = this.ratioWeightHeightPass;
321 | 	var weight = 0;
322 | 	var finalOffset = 0;
323 | 	var pixelOffset = 0;
324 | 	var pixelOffsetAccumulated = 0;
325 | 	var pixelOffsetAccumulated2 = 0;
326 | 	var firstWeight = 0;
327 | 	var secondWeight = 0;
328 | 	var outputBuffer = this.heightBuffer;
329 | 	//Handle for only one interpolation input being valid for start calculation:
330 | 	for (; weight < 1/3; weight += ratioWeight) {
331 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
332 | 			outputBuffer[finalOffset++] = Math.round(buffer[pixelOffset++]);
333 | 		}
334 | 	}
335 | 	//Adjust for overshoot of the last pass's counter:
336 | 	weight -= 1/3;
337 | 	for (var interpolationHeightSourceReadStop = this.heightOriginal - 1; weight < interpolationHeightSourceReadStop; weight += ratioWeight) {
338 | 		//Calculate weightings:
339 | 		secondWeight = weight % 1;
340 | 		firstWeight = 1 - secondWeight;
341 | 		//Interpolate:
342 | 		pixelOffsetAccumulated = Math.floor(weight) * this.targetWidthMultipliedByChannels;
343 | 		pixelOffsetAccumulated2 = pixelOffsetAccumulated + this.targetWidthMultipliedByChannels;
344 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
345 | 			outputBuffer[finalOffset++] = Math.round((buffer[pixelOffsetAccumulated++] * firstWeight) + (buffer[pixelOffsetAccumulated2++] * secondWeight));
346 | 		}
347 | 	}
348 | 	//Handle for only one interpolation input being valid for end calculation:
349 | 	while (finalOffset < this.finalResultSize) {
350 | 		for (pixelOffset = 0, pixelOffsetAccumulated = interpolationHeightSourceReadStop * this.targetWidthMultipliedByChannels; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
351 | 			outputBuffer[finalOffset++] = Math.round(buffer[pixelOffsetAccumulated++]);
352 | 		}
353 | 	}
354 | 	return outputBuffer;
355 | }
356 | Resize.prototype.resizeHeightRGBA = function (buffer) {
357 | 	var ratioWeight = this.ratioWeightHeightPass;
358 | 	var ratioWeightDivisor = 1 / ratioWeight;
359 | 	var weight = 0;
360 | 	var amountToNext = 0;
361 | 	var actualPosition = 0;
362 | 	var currentPosition = 0;
363 | 	var pixelOffset = 0;
364 | 	var outputOffset = 0;
365 | 	var output = this.outputHeightWorkBench;
366 | 	var outputBuffer = this.heightBuffer;
367 | 	do {
368 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
369 | 			output[pixelOffset++] = 0;
370 | 			output[pixelOffset++] = 0;
371 | 			output[pixelOffset++] = 0;
372 | 			output[pixelOffset++] = 0;
373 | 		}
374 | 		weight = ratioWeight;
375 | 		do {
376 | 			amountToNext = 1 + actualPosition - currentPosition;
377 | 			if (weight >= amountToNext) {
378 | 				for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
379 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
380 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
381 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
382 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
383 | 				}
384 | 				currentPosition = actualPosition;
385 | 				weight -= amountToNext;
386 | 			}
387 | 			else {
388 | 				for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
389 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
390 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
391 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
392 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
393 | 				}
394 | 				currentPosition += weight;
395 | 				break;
396 | 			}
397 | 		} while (weight > 0 && actualPosition < this.widthPassResultSize);
398 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
399 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
400 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
401 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
402 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
403 | 		}
404 | 	} while (outputOffset < this.finalResultSize);
405 | 	return outputBuffer;
406 | }
407 | Resize.prototype.resize = function (buffer) {
408 | 	if (this.useWebWorker) {
409 | 		this.worker.postMessage(["resize", buffer]);
410 | 	}
411 | 	else {
412 | 		this.resizeCallback(this.resizeHeight(this.resizeWidth(buffer)));
413 | 	}
414 | }
415 | Resize.prototype.bypassResizer = function (buffer) {
416 | 	//Just return the buffer passsed:
417 | 	return buffer;
418 | }
419 | Resize.prototype.initializeFirstPassBuffers = function (BILINEARAlgo) {
420 | 	//Initialize the internal width pass buffers:
421 | 	this.widthBuffer = this.generateFloatBuffer(this.widthPassResultSize);
422 | 	if (!BILINEARAlgo) {
423 | 		this.outputWidthWorkBench = this.generateFloatBuffer(this.originalHeightMultipliedByChannels);
424 | 	}
425 | }
426 | Resize.prototype.initializeSecondPassBuffers = function (BILINEARAlgo) {
427 | 	//Initialize the internal height pass buffers:
428 | 	this.heightBuffer = this.generateUint8Buffer(this.finalResultSize);
429 | 	if (!BILINEARAlgo) {
430 | 		this.outputHeightWorkBench = this.generateFloatBuffer(this.targetWidthMultipliedByChannels);
431 | 	}
432 | }
433 | Resize.prototype.generateFloatBuffer = function (bufferLength) {
434 | 	//Generate a float32 typed array buffer:
435 | 	try {
436 | 		return new Float32Array(bufferLength);
437 | 	}
438 | 	catch (error) {
439 | 		return [];
440 | 	}
441 | }
442 | Resize.prototype.generateUint8Buffer = function (bufferLength) {
443 | 	//Generate a uint8 typed array buffer:
444 | 	try {
445 | 		return new Uint8Array(bufferLength);
446 | 	}
447 | 	catch (error) {
448 | 		return [];
449 | 	}
450 | }


--------------------------------------------------------------------------------
/js/other/resizeWorker.js:
--------------------------------------------------------------------------------
  1 | //JavaScript Image Resizer (c) 2012 - Grant Galitz
  2 | var resizeWorker = null;
  3 | self.onmessage = function (event) {
  4 | 	switch (event.data[0]) {
  5 | 		case "setup":
  6 | 			resizeWorker = new Resize(event.data[1], event.data[2], event.data[3], event.data[4], event.data[5], event.data[6]);
  7 | 			break;
  8 | 		case "resize":
  9 | 			resizeWorker.resize(event.data[1]);
 10 | 	}
 11 | }
 12 | function Resize(widthOriginal, heightOriginal, targetWidth, targetHeight, colorChannels, interpolationPass) {
 13 | 	this.widthOriginal = widthOriginal;
 14 | 	this.heightOriginal = heightOriginal;
 15 | 	this.targetWidth = targetWidth;
 16 | 	this.targetHeight = targetHeight;
 17 | 	this.colorChannels = colorChannels;
 18 | 	this.interpolationPass = !!interpolationPass;
 19 | 	this.targetWidthMultipliedByChannels = this.targetWidth * this.colorChannels;
 20 | 	this.originalWidthMultipliedByChannels = this.widthOriginal * this.colorChannels;
 21 | 	this.originalHeightMultipliedByChannels = this.heightOriginal * this.colorChannels;
 22 | 	this.widthPassResultSize = this.targetWidthMultipliedByChannels * this.heightOriginal;
 23 | 	this.finalResultSize = this.targetWidthMultipliedByChannels * this.targetHeight;
 24 | 	this.initialize();
 25 | }
 26 | Resize.prototype.initialize = function () {
 27 | 	//Perform some checks:
 28 | 	if (this.widthOriginal > 0 && this.heightOriginal > 0 && this.targetWidth > 0 && this.targetHeight > 0) {
 29 | 		this.configurePasses();
 30 | 	}
 31 | 	else {
 32 | 		throw(new Error("Invalid settings specified for the resizer."));
 33 | 	}
 34 | }
 35 | Resize.prototype.configurePasses = function () {
 36 | 	if (this.widthOriginal == this.targetWidth) {
 37 | 		//Bypass the width resizer pass:
 38 | 		this.resizeWidth = this.bypassResizer;
 39 | 	}
 40 | 	else {
 41 | 		//Setup the width resizer pass:
 42 | 		this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
 43 | 		if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
 44 | 			this.initializeFirstPassBuffers(true);
 45 | 			this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthInterpolatedRGBA : this.resizeWidthInterpolatedRGB;
 46 | 		}
 47 | 		else {
 48 | 			this.initializeFirstPassBuffers(false);
 49 | 			this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthRGBA : this.resizeWidthRGB;
 50 | 		}
 51 | 	}
 52 | 	if (this.heightOriginal == this.targetHeight) {
 53 | 		//Bypass the height resizer pass:
 54 | 		this.resizeHeight = this.bypassResizer;
 55 | 	}
 56 | 	else {	
 57 | 		//Setup the height resizer pass:
 58 | 		this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
 59 | 		if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
 60 | 			this.initializeSecondPassBuffers(true);
 61 | 			this.resizeHeight = this.resizeHeightInterpolated;
 62 | 		}
 63 | 		else {
 64 | 			this.initializeSecondPassBuffers(false);
 65 | 			this.resizeHeight = (this.colorChannels == 4) ? this.resizeHeightRGBA : this.resizeHeightRGB;
 66 | 		}
 67 | 	}
 68 | }
 69 | Resize.prototype.resizeWidthRGB = function (buffer) {
 70 | 	var ratioWeight = this.ratioWeightWidthPass;
 71 | 	var ratioWeightDivisor = 1 / ratioWeight;
 72 | 	var weight = 0;
 73 | 	var amountToNext = 0;
 74 | 	var actualPosition = 0;
 75 | 	var currentPosition = 0;
 76 | 	var line = 0;
 77 | 	var pixelOffset = 0;
 78 | 	var outputOffset = 0;
 79 | 	var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 2;
 80 | 	var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 2;
 81 | 	var output = this.outputWidthWorkBench;
 82 | 	var outputBuffer = this.widthBuffer;
 83 | 	do {
 84 | 		for (line = 0; line < this.originalHeightMultipliedByChannels;) {
 85 | 			output[line++] = 0;
 86 | 			output[line++] = 0;
 87 | 			output[line++] = 0;
 88 | 		}
 89 | 		weight = ratioWeight;
 90 | 		do {
 91 | 			amountToNext = 1 + actualPosition - currentPosition;
 92 | 			if (weight >= amountToNext) {
 93 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
 94 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
 95 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
 96 | 					output[line++] += buffer[pixelOffset] * amountToNext;
 97 | 				}
 98 | 				currentPosition = actualPosition = actualPosition + 3;
 99 | 				weight -= amountToNext;
100 | 			}
101 | 			else {
102 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
103 | 					output[line++] += buffer[pixelOffset++] * weight;
104 | 					output[line++] += buffer[pixelOffset++] * weight;
105 | 					output[line++] += buffer[pixelOffset] * weight;
106 | 				}
107 | 				currentPosition += weight;
108 | 				break;
109 | 			}
110 | 		} while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
111 | 		for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
112 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
113 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
114 | 			outputBuffer[pixelOffset] = output[line++] * ratioWeightDivisor;
115 | 		}
116 | 		outputOffset += 3;
117 | 	} while (outputOffset < this.targetWidthMultipliedByChannels);
118 | 	return outputBuffer;
119 | }
120 | Resize.prototype.resizeWidthInterpolatedRGB = function (buffer) {
121 | 	var ratioWeight = this.ratioWeightWidthPass;
122 | 	var weight = 0;
123 | 	var finalOffset = 0;
124 | 	var pixelOffset = 0;
125 | 	var firstWeight = 0;
126 | 	var secondWeight = 0;
127 | 	var outputBuffer = this.widthBuffer;
128 | 	//Handle for only one interpolation input being valid for start calculation:
129 | 	for (var targetPosition = 0; weight < 1/3; targetPosition += 3, weight += ratioWeight) {
130 | 		for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
131 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
132 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
133 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
134 | 		}
135 | 	}
136 | 	//Adjust for overshoot of the last pass's counter:
137 | 	weight -= 1/3;
138 | 	for (var interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += 3, weight += ratioWeight) {
139 | 		//Calculate weightings:
140 | 		secondWeight = weight % 1;
141 | 		firstWeight = 1 - secondWeight;
142 | 		//Interpolate:
143 | 		for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 3; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
144 | 			outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 3] * secondWeight);
145 | 			outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
146 | 			outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
147 | 		}
148 | 	}
149 | 	//Handle for only one interpolation input being valid for end calculation:
150 | 	for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - 3; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 3) {
151 | 		for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
152 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
153 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
154 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
155 | 		}
156 | 	}
157 | 	return outputBuffer;
158 | }
159 | Resize.prototype.resizeWidthRGBA = function (buffer) {
160 | 	var ratioWeight = this.ratioWeightWidthPass;
161 | 	var ratioWeightDivisor = 1 / ratioWeight;
162 | 	var weight = 0;
163 | 	var amountToNext = 0;
164 | 	var actualPosition = 0;
165 | 	var currentPosition = 0;
166 | 	var line = 0;
167 | 	var pixelOffset = 0;
168 | 	var outputOffset = 0;
169 | 	var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 3;
170 | 	var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 3;
171 | 	var output = this.outputWidthWorkBench;
172 | 	var outputBuffer = this.widthBuffer;
173 | 	do {
174 | 		for (line = 0; line < this.originalHeightMultipliedByChannels;) {
175 | 			output[line++] = 0;
176 | 			output[line++] = 0;
177 | 			output[line++] = 0;
178 | 			output[line++] = 0;
179 | 		}
180 | 		weight = ratioWeight;
181 | 		do {
182 | 			amountToNext = 1 + actualPosition - currentPosition;
183 | 			if (weight >= amountToNext) {
184 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
185 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
186 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
187 | 					output[line++] += buffer[pixelOffset++] * amountToNext;
188 | 					output[line++] += buffer[pixelOffset] * amountToNext;
189 | 				}
190 | 				currentPosition = actualPosition = actualPosition + 4;
191 | 				weight -= amountToNext;
192 | 			}
193 | 			else {
194 | 				for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
195 | 					output[line++] += buffer[pixelOffset++] * weight;
196 | 					output[line++] += buffer[pixelOffset++] * weight;
197 | 					output[line++] += buffer[pixelOffset++] * weight;
198 | 					output[line++] += buffer[pixelOffset] * weight;
199 | 				}
200 | 				currentPosition += weight;
201 | 				break;
202 | 			}
203 | 		} while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
204 | 		for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
205 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
206 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
207 | 			outputBuffer[pixelOffset++] = output[line++] * ratioWeightDivisor;
208 | 			outputBuffer[pixelOffset] = output[line++] * ratioWeightDivisor;
209 | 		}
210 | 		outputOffset += 4;
211 | 	} while (outputOffset < this.targetWidthMultipliedByChannels);
212 | 	return outputBuffer;
213 | }
214 | Resize.prototype.resizeWidthInterpolatedRGBA = function (buffer) {
215 | 	var ratioWeight = this.ratioWeightWidthPass;
216 | 	var weight = 0;
217 | 	var finalOffset = 0;
218 | 	var pixelOffset = 0;
219 | 	var firstWeight = 0;
220 | 	var secondWeight = 0;
221 | 	var outputBuffer = this.widthBuffer;
222 | 	//Handle for only one interpolation input being valid for start calculation:
223 | 	for (var targetPosition = 0; weight < 1/3; targetPosition += 4, weight += ratioWeight) {
224 | 		for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
225 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
226 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
227 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
228 | 			outputBuffer[finalOffset + 3] = buffer[pixelOffset + 3];
229 | 		}
230 | 	}
231 | 	//Adjust for overshoot of the last pass's counter:
232 | 	weight -= 1/3;
233 | 	for (var interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += 4, weight += ratioWeight) {
234 | 		//Calculate weightings:
235 | 		secondWeight = weight % 1;
236 | 		firstWeight = 1 - secondWeight;
237 | 		//Interpolate:
238 | 		for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 4; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
239 | 			outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
240 | 			outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
241 | 			outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 6] * secondWeight);
242 | 			outputBuffer[finalOffset + 3] = (buffer[pixelOffset + 3] * firstWeight) + (buffer[pixelOffset + 7] * secondWeight);
243 | 		}
244 | 	}
245 | 	//Handle for only one interpolation input being valid for end calculation:
246 | 	for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - 4; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 4) {
247 | 		for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
248 | 			outputBuffer[finalOffset] = buffer[pixelOffset];
249 | 			outputBuffer[finalOffset + 1] = buffer[pixelOffset + 1];
250 | 			outputBuffer[finalOffset + 2] = buffer[pixelOffset + 2];
251 | 			outputBuffer[finalOffset + 3] = buffer[pixelOffset + 3];
252 | 		}
253 | 	}
254 | 	return outputBuffer;
255 | }
256 | Resize.prototype.resizeHeightRGB = function (buffer) {
257 | 	var ratioWeight = this.ratioWeightHeightPass;
258 | 	var ratioWeightDivisor = 1 / ratioWeight;
259 | 	var weight = 0;
260 | 	var amountToNext = 0;
261 | 	var actualPosition = 0;
262 | 	var currentPosition = 0;
263 | 	var pixelOffset = 0;
264 | 	var outputOffset = 0;
265 | 	var output = this.outputHeightWorkBench;
266 | 	var outputBuffer = this.heightBuffer;
267 | 	do {
268 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
269 | 			output[pixelOffset++] = 0;
270 | 			output[pixelOffset++] = 0;
271 | 			output[pixelOffset++] = 0;
272 | 		}
273 | 		weight = ratioWeight;
274 | 		do {
275 | 			amountToNext = 1 + actualPosition - currentPosition;
276 | 			if (weight >= amountToNext) {
277 | 				for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
278 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
279 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
280 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
281 | 				}
282 | 				currentPosition = actualPosition;
283 | 				weight -= amountToNext;
284 | 			}
285 | 			else {
286 | 				for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
287 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
288 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
289 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
290 | 				}
291 | 				currentPosition += weight;
292 | 				break;
293 | 			}
294 | 		} while (weight > 0 && actualPosition < this.widthPassResultSize);
295 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
296 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
297 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
298 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
299 | 		}
300 | 	} while (outputOffset < this.finalResultSize);
301 | 	return outputBuffer;
302 | }
303 | Resize.prototype.resizeHeightInterpolated = function (buffer) {
304 | 	var ratioWeight = this.ratioWeightHeightPass;
305 | 	var weight = 0;
306 | 	var finalOffset = 0;
307 | 	var pixelOffset = 0;
308 | 	var pixelOffsetAccumulated = 0;
309 | 	var pixelOffsetAccumulated2 = 0;
310 | 	var firstWeight = 0;
311 | 	var secondWeight = 0;
312 | 	var outputBuffer = this.heightBuffer;
313 | 	//Handle for only one interpolation input being valid for start calculation:
314 | 	for (; weight < 1/3; weight += ratioWeight) {
315 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
316 | 			outputBuffer[finalOffset++] = Math.round(buffer[pixelOffset++]);
317 | 		}
318 | 	}
319 | 	//Adjust for overshoot of the last pass's counter:
320 | 	weight -= 1/3;
321 | 	for (var interpolationHeightSourceReadStop = this.heightOriginal - 1; weight < interpolationHeightSourceReadStop; weight += ratioWeight) {
322 | 		//Calculate weightings:
323 | 		secondWeight = weight % 1;
324 | 		firstWeight = 1 - secondWeight;
325 | 		//Interpolate:
326 | 		pixelOffsetAccumulated = Math.floor(weight) * this.targetWidthMultipliedByChannels;
327 | 		pixelOffsetAccumulated2 = pixelOffsetAccumulated + this.targetWidthMultipliedByChannels;
328 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
329 | 			outputBuffer[finalOffset++] = Math.round((buffer[pixelOffsetAccumulated++] * firstWeight) + (buffer[pixelOffsetAccumulated2++] * secondWeight));
330 | 		}
331 | 	}
332 | 	//Handle for only one interpolation input being valid for end calculation:
333 | 	while (finalOffset < this.finalResultSize) {
334 | 		for (pixelOffset = 0, pixelOffsetAccumulated = interpolationHeightSourceReadStop * this.targetWidthMultipliedByChannels; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
335 | 			outputBuffer[finalOffset++] = Math.round(buffer[pixelOffsetAccumulated++]);
336 | 		}
337 | 	}
338 | 	return outputBuffer;
339 | }
340 | Resize.prototype.resizeHeightRGBA = function (buffer) {
341 | 	var ratioWeight = this.ratioWeightHeightPass;
342 | 	var ratioWeightDivisor = 1 / ratioWeight;
343 | 	var weight = 0;
344 | 	var amountToNext = 0;
345 | 	var actualPosition = 0;
346 | 	var currentPosition = 0;
347 | 	var pixelOffset = 0;
348 | 	var outputOffset = 0;
349 | 	var output = this.outputHeightWorkBench;
350 | 	var outputBuffer = this.heightBuffer;
351 | 	do {
352 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
353 | 			output[pixelOffset++] = 0;
354 | 			output[pixelOffset++] = 0;
355 | 			output[pixelOffset++] = 0;
356 | 			output[pixelOffset++] = 0;
357 | 		}
358 | 		weight = ratioWeight;
359 | 		do {
360 | 			amountToNext = 1 + actualPosition - currentPosition;
361 | 			if (weight >= amountToNext) {
362 | 				for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
363 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
364 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
365 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
366 | 					output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
367 | 				}
368 | 				currentPosition = actualPosition;
369 | 				weight -= amountToNext;
370 | 			}
371 | 			else {
372 | 				for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
373 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
374 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
375 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
376 | 					output[pixelOffset++] += buffer[amountToNext++] * weight;
377 | 				}
378 | 				currentPosition += weight;
379 | 				break;
380 | 			}
381 | 		} while (weight > 0 && actualPosition < this.widthPassResultSize);
382 | 		for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
383 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
384 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
385 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
386 | 			outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
387 | 		}
388 | 	} while (outputOffset < this.finalResultSize);
389 | 	return outputBuffer;
390 | }
391 | Resize.prototype.resize = function (buffer) {
392 | 	self.postMessage(this.resizeHeight(this.resizeWidth(buffer)));
393 | }
394 | Resize.prototype.bypassResizer = function (buffer) {
395 | 	//Just return the buffer passsed:
396 | 	return buffer;
397 | }
398 | Resize.prototype.initializeFirstPassBuffers = function (BILINEARAlgo) {
399 | 	//Initialize the internal width pass buffers:
400 | 	this.widthBuffer = this.generateFloatBuffer(this.widthPassResultSize);
401 | 	if (!BILINEARAlgo) {
402 | 		this.outputWidthWorkBench = this.generateFloatBuffer(this.originalHeightMultipliedByChannels);
403 | 	}
404 | }
405 | Resize.prototype.initializeSecondPassBuffers = function (BILINEARAlgo) {
406 | 	//Initialize the internal height pass buffers:
407 | 	this.heightBuffer = this.generateUint8Buffer(this.finalResultSize);
408 | 	if (!BILINEARAlgo) {
409 | 		this.outputHeightWorkBench = this.generateFloatBuffer(this.targetWidthMultipliedByChannels);
410 | 	}
411 | }
412 | Resize.prototype.generateFloatBuffer = function (bufferLength) {
413 | 	//Generate a float32 typed array buffer:
414 | 	try {
415 | 		return new Float32Array(bufferLength);
416 | 	}
417 | 	catch (error) {
418 | 		return [];
419 | 	}
420 | }
421 | Resize.prototype.generateUint8Buffer = function (bufferLength) {
422 | 	//Generate a uint8 typed array buffer:
423 | 	try {
424 | 		return new Uint8Array(bufferLength);
425 | 	}
426 | 	catch (error) {
427 | 		return [];
428 | 	}
429 | }


--------------------------------------------------------------------------------
/js/other/swfobject.js:
--------------------------------------------------------------------------------
1 | /*	SWFObject v2.2 <http://code.google.com/p/swfobject/> 
2 | 	is released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
3 | */
4 | var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;if(typeof t.plugins!=D&&typeof t.plugins[S]==r){ab=t.plugins[S].description;if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){T=true;X=false;ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0}}else{if(typeof O.ActiveXObject!=D){try{var ad=new ActiveXObject(W);if(ad){ab=ad.GetVariable("$version");if(ab){X=true;ab=ab.split(" ")[1].split(",");ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}}catch(Z){}}}return{w3:aa,pv:ag,wk:af,ie:X,win:ae,mac:ac}}(),k=function(){if(!M.w3){return}if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){f()}if(!J){if(typeof j.addEventListener!=D){j.addEventListener("DOMContentLoaded",f,false)}if(M.ie&&M.win){j.attachEvent(x,function(){if(j.readyState=="complete"){j.detachEvent(x,arguments.callee);f()}});if(O==top){(function(){if(J){return}try{j.documentElement.doScroll("left")}catch(X){setTimeout(arguments.callee,0);return}f()})()}}if(M.wk){(function(){if(J){return}if(!/loaded|complete/.test(j.readyState)){setTimeout(arguments.callee,0);return}f()})()}s(f)}}();function f(){if(J){return}try{var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));Z.parentNode.removeChild(Z)}catch(aa){return}J=true;var X=U.length;for(var Y=0;Y<X;Y++){U[Y]()}}function K(X){if(J){X()}else{U[U.length]=X}}function s(Y){if(typeof O.addEventListener!=D){O.addEventListener("load",Y,false)}else{if(typeof j.addEventListener!=D){j.addEventListener("load",Y,false)}else{if(typeof O.attachEvent!=D){i(O,"onload",Y)}else{if(typeof O.onload=="function"){var X=O.onload;O.onload=function(){X();Y()}}else{O.onload=Y}}}}}function h(){if(T){V()}else{H()}}function V(){var X=j.getElementsByTagName("body")[0];var aa=C(r);aa.setAttribute("type",q);var Z=X.appendChild(aa);if(Z){var Y=0;(function(){if(typeof Z.GetVariable!=D){var ab=Z.GetVariable("$version");if(ab){ab=ab.split(" ")[1].split(",");M.pv=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}else{if(Y<10){Y++;setTimeout(arguments.callee,10);return}}X.removeChild(aa);Z=null;H()})()}else{H()}}function H(){var ag=o.length;if(ag>0){for(var af=0;af<ag;af++){var Y=o[af].id;var ab=o[af].callbackFn;var aa={success:false,id:Y};if(M.pv[0]>0){var ae=c(Y);if(ae){if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){w(Y,true);if(ab){aa.success=true;aa.ref=z(Y);ab(aa)}}else{if(o[af].expressInstall&&A()){var ai={};ai.data=o[af].expressInstall;ai.width=ae.getAttribute("width")||"0";ai.height=ae.getAttribute("height")||"0";if(ae.getAttribute("class")){ai.styleclass=ae.getAttribute("class")}if(ae.getAttribute("align")){ai.align=ae.getAttribute("align")}var ah={};var X=ae.getElementsByTagName("param");var ac=X.length;for(var ad=0;ad<ac;ad++){if(X[ad].getAttribute("name").toLowerCase()!="movie"){ah[X[ad].getAttribute("name")]=X[ad].getAttribute("value")}}P(ai,ah,Y,ab)}else{p(ae);if(ab){ab(aa)}}}}}else{w(Y,true);if(ab){var Z=z(Y);if(Z&&typeof Z.SetVariable!=D){aa.success=true;aa.ref=Z}ab(aa)}}}}}function z(aa){var X=null;var Y=c(aa);if(Y&&Y.nodeName=="OBJECT"){if(typeof Y.SetVariable!=D){X=Y}else{var Z=Y.getElementsByTagName(r)[0];if(Z){X=Z}}}return X}function A(){return !a&&F("6.0.65")&&(M.win||M.mac)&&!(M.wk&&M.wk<312)}function P(aa,ab,X,Z){a=true;E=Z||null;B={success:false,id:X};var ae=c(X);if(ae){if(ae.nodeName=="OBJECT"){l=g(ae);Q=null}else{l=ae;Q=X}aa.id=R;if(typeof aa.width==D||(!/%$/.test(aa.width)&&parseInt(aa.width,10)<310)){aa.width="310"}if(typeof aa.height==D||(!/%$/.test(aa.height)&&parseInt(aa.height,10)<137)){aa.height="137"}j.title=j.title.slice(0,47)+" - Flash Player Installation";var ad=M.ie&&M.win?"ActiveX":"PlugIn",ac="MMredirectURL="+O.location.toString().replace(/&/g,"%26")+"&MMplayerType="+ad+"&MMdoctitle="+j.title;if(typeof ab.flashvars!=D){ab.flashvars+="&"+ac}else{ab.flashvars=ac}if(M.ie&&M.win&&ae.readyState!=4){var Y=C("div");X+="SWFObjectNew";Y.setAttribute("id",X);ae.parentNode.insertBefore(Y,ae);ae.style.display="none";(function(){if(ae.readyState==4){ae.parentNode.removeChild(ae)}else{setTimeout(arguments.callee,10)}})()}u(aa,ab,X)}}function p(Y){if(M.ie&&M.win&&Y.readyState!=4){var X=C("div");Y.parentNode.insertBefore(X,Y);X.parentNode.replaceChild(g(Y),X);Y.style.display="none";(function(){if(Y.readyState==4){Y.parentNode.removeChild(Y)}else{setTimeout(arguments.callee,10)}})()}else{Y.parentNode.replaceChild(g(Y),Y)}}function g(ab){var aa=C("div");if(M.win&&M.ie){aa.innerHTML=ab.innerHTML}else{var Y=ab.getElementsByTagName(r)[0];if(Y){var ad=Y.childNodes;if(ad){var X=ad.length;for(var Z=0;Z<X;Z++){if(!(ad[Z].nodeType==1&&ad[Z].nodeName=="PARAM")&&!(ad[Z].nodeType==8)){aa.appendChild(ad[Z].cloneNode(true))}}}}}return aa}function u(ai,ag,Y){var X,aa=c(Y);if(M.wk&&M.wk<312){return X}if(aa){if(typeof ai.id==D){ai.id=Y}if(M.ie&&M.win){var ah="";for(var ae in ai){if(ai[ae]!=Object.prototype[ae]){if(ae.toLowerCase()=="data"){ag.movie=ai[ae]}else{if(ae.toLowerCase()=="styleclass"){ah+=' class="'+ai[ae]+'"'}else{if(ae.toLowerCase()!="classid"){ah+=" "+ae+'="'+ai[ae]+'"'}}}}}var af="";for(var ad in ag){if(ag[ad]!=Object.prototype[ad]){af+='<param name="'+ad+'" value="'+ag[ad]+'" />'}}aa.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+ah+">"+af+"</object>";N[N.length]=ai.id;X=c(ai.id)}else{var Z=C(r);Z.setAttribute("type",q);for(var ac in ai){if(ai[ac]!=Object.prototype[ac]){if(ac.toLowerCase()=="styleclass"){Z.setAttribute("class",ai[ac])}else{if(ac.toLowerCase()!="classid"){Z.setAttribute(ac,ai[ac])}}}}for(var ab in ag){if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){e(Z,ab,ag[ab])}}aa.parentNode.replaceChild(Z,aa);X=Z}}return X}function e(Z,X,Y){var aa=C("param");aa.setAttribute("name",X);aa.setAttribute("value",Y);Z.appendChild(aa)}function y(Y){var X=c(Y);if(X&&X.nodeName=="OBJECT"){if(M.ie&&M.win){X.style.display="none";(function(){if(X.readyState==4){b(Y)}else{setTimeout(arguments.callee,10)}})()}else{X.parentNode.removeChild(X)}}}function b(Z){var Y=c(Z);if(Y){for(var X in Y){if(typeof Y[X]=="function"){Y[X]=null}}Y.parentNode.removeChild(Y)}}function c(Z){var X=null;try{X=j.getElementById(Z)}catch(Y){}return X}function C(X){return j.createElement(X)}function i(Z,X,Y){Z.attachEvent(X,Y);I[I.length]=[Z,X,Y]}function F(Z){var Y=M.pv,X=Z.split(".");X[0]=parseInt(X[0],10);X[1]=parseInt(X[1],10)||0;X[2]=parseInt(X[2],10)||0;return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false}function v(ac,Y,ad,ab){if(M.ie&&M.mac){return}var aa=j.getElementsByTagName("head")[0];if(!aa){return}var X=(ad&&typeof ad=="string")?ad:"screen";if(ab){n=null;G=null}if(!n||G!=X){var Z=C("style");Z.setAttribute("type","text/css");Z.setAttribute("media",X);n=aa.appendChild(Z);if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){n=j.styleSheets[j.styleSheets.length-1]}G=X}if(M.ie&&M.win){if(n&&typeof n.addRule==r){n.addRule(ac,Y)}}else{if(n&&typeof j.createTextNode!=D){n.appendChild(j.createTextNode(ac+" {"+Y+"}"))}}}function w(Z,X){if(!m){return}var Y=X?"visible":"hidden";if(J&&c(Z)){c(Z).style.visibility=Y}else{v("#"+Z,"visibility:"+Y)}}function L(Y){var Z=/[\\\"<>\.;]/;var X=Z.exec(Y)!=null;return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y}var d=function(){if(M.ie&&M.win){window.attachEvent("onunload",function(){var ac=I.length;for(var ab=0;ab<ac;ab++){I[ab][0].detachEvent(I[ab][1],I[ab][2])}var Z=N.length;for(var aa=0;aa<Z;aa++){y(N[aa])}for(var Y in M){M[Y]=null}M=null;for(var X in swfobject){swfobject[X]=null}swfobject=null})}}();return{registerObject:function(ab,X,aa,Z){if(M.w3&&ab&&X){var Y={};Y.id=ab;Y.swfVersion=X;Y.expressInstall=aa;Y.callbackFn=Z;o[o.length]=Y;w(ab,false)}else{if(Z){Z({success:false,id:ab})}}},getObjectById:function(X){if(M.w3){return z(X)}},embedSWF:function(ab,ah,ae,ag,Y,aa,Z,ad,af,ac){var X={success:false,id:ah};if(M.w3&&!(M.wk&&M.wk<312)&&ab&&ah&&ae&&ag&&Y){w(ah,false);K(function(){ae+="";ag+="";var aj={};if(af&&typeof af===r){for(var al in af){aj[al]=af[al]}}aj.data=ab;aj.width=ae;aj.height=ag;var am={};if(ad&&typeof ad===r){for(var ak in ad){am[ak]=ad[ak]}}if(Z&&typeof Z===r){for(var ai in Z){if(typeof am.flashvars!=D){am.flashvars+="&"+ai+"="+Z[ai]}else{am.flashvars=ai+"="+Z[ai]}}}if(F(Y)){var an=u(aj,am,ah);if(aj.id==ah){w(ah,true)}X.success=true;X.ref=an}else{if(aa&&A()){aj.data=aa;P(aj,am,ah,ac);return}else{w(ah,true)}}if(ac){ac(X)}})}else{if(ac){ac(X)}}},switchOffAutoHideShow:function(){m=false},ua:M,getFlashPlayerVersion:function(){return{major:M.pv[0],minor:M.pv[1],release:M.pv[2]}},hasFlashPlayerVersion:F,createSWF:function(Z,Y,X){if(M.w3){return u(Z,Y,X)}else{return undefined}},showExpressInstall:function(Z,aa,X,Y){if(M.w3&&A()){P(Z,aa,X,Y)}},removeSWF:function(X){if(M.w3){y(X)}},createCSS:function(aa,Z,Y,X){if(M.w3){v(aa,Z,Y,X)}},addDomLoadEvent:K,addLoadEvent:s,getQueryParamValue:function(aa){var Z=j.location.search||j.location.hash;if(Z){if(/\?/.test(Z)){Z=Z.split("?")[1]}if(aa==null){return L(Z)}var Y=Z.split("&");for(var X=0;X<Y.length;X++){if(Y[X].substring(0,Y[X].indexOf("="))==aa){return L(Y[X].substring((Y[X].indexOf("=")+1)))}}}return""},expressInstallCallback:function(){if(a){var X=c(R);if(X&&l){X.parentNode.replaceChild(l,X);if(Q){w(Q,true);if(M.ie&&M.win){l.style.display="block"}}if(E){E(B)}}a=false}}}}();


--------------------------------------------------------------------------------
/js/other/terminal.js:
--------------------------------------------------------------------------------
 1 | function cout(message, colorIndex) {
 2 | 	var terminal_output = document.getElementById("terminal_output");
 3 | 	if ((colorIndex != 0 || DEBUG_MESSAGES) && (colorIndex != -1 || DEBUG_WINDOWING)) {
 4 | 		var lineout = document.createElement('span');
 5 | 		lineout.appendChild(document.createTextNode(message));
 6 | 		switch (colorIndex) {
 7 | 			case -1:
 8 | 			case 0:
 9 | 				lineout.className = "white";
10 | 				break;
11 | 			case 1:
12 | 				lineout.className = "yellow";
13 | 				break;
14 | 			case 2:
15 | 				lineout.className = "red";
16 | 		}
17 | 		terminal_output.appendChild(lineout);
18 | 		terminal_output.appendChild(document.createElement('br'));
19 | 		terminal_output.scrollTop = terminal_output.scrollHeight - terminal_output.clientHeight;
20 | 	}
21 | }
22 | function clear_terminal() {
23 | 	var terminal_output = document.getElementById("terminal_output");
24 | 	while (terminal_output.firstChild != null) {
25 | 		terminal_output.removeChild(terminal_output.firstChild);
26 | 	}
27 | }


--------------------------------------------------------------------------------
/js/other/windowStack.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var windowStacks = [];
  3 | function windowCreate(sId, bShow) {
  4 | 	var oWindow = new windowStack(document.getElementById(sId));
  5 | 	if (bShow) {
  6 | 		oWindow.show();
  7 | 	}
  8 | 	return oWindow;
  9 | }
 10 | function windowStack(element) {
 11 | 	if (element != null && typeof element == "object") {
 12 | 		this.lastOpacity = null;
 13 | 		this.domObject = element;
 14 | 		this.hadFocus = true;
 15 | 		this.hookedMouse = false;
 16 | 		var thisObj2 = this;
 17 | 		this.events = [
 18 | 			["mousedown", function (event) { thisObj2.dragEnable(event); }],
 19 | 			["mousemove", function (event) { thisObj2.drag(event); }],
 20 | 			["mouseup", function (event) { thisObj2.dragDisable(); }]
 21 | 		];
 22 | 	}
 23 | }
 24 | windowStack.prototype.registerMouseEvents = function () {
 25 | 	if (!this.hookedMouse) {
 26 | 		this.hookedMouse = true;
 27 | 		var eventIndex = null;
 28 | 		for (eventIndex in this.events) {
 29 | 			addEvent(this.events[eventIndex][0], document, this.events[eventIndex][1]);
 30 | 		}
 31 | 		this.center();
 32 | 	}
 33 | }
 34 | windowStack.prototype.unregisterMouseEvents = function () {
 35 | 	if (this.hookedMouse) {
 36 | 		this.hookedMouse = false;
 37 | 		var eventIndex = null;
 38 | 		for (eventIndex in this.events) {
 39 | 			removeEvent(this.events[eventIndex][0], document, this.events[eventIndex][1]);
 40 | 		}
 41 | 	}
 42 | }
 43 | windowStack.prototype.getStyleFloatOf = function (propertyNameOf, JSpropertyNameOf) {
 44 | 	try {
 45 | 		var dirtyValue = window.getComputedStyle(this.domObject, null).getPropertyValue(propertyNameOf);
 46 | 	}
 47 | 	catch (error) {
 48 | 		try {
 49 | 			var dirtyValue = this.domObject.currentStyle.getAttribute(JSpropertyNameOf);	/*JS object notation style keywords, not the CSS keywords!*/
 50 | 		}
 51 | 		catch (error) {
 52 | 			cout(error.message, 2);
 53 | 		}
 54 | 	}
 55 | 	var cleanValue = parseFloat((dirtyValue != null && dirtyValue.length) ? dirtyValue : "0");
 56 | 	return (!isNaN(cleanValue) && cleanValue != -1) ? cleanValue : 0;	/*Note: Opera gives -1, not NaN for cleanValue when no number is found.*/
 57 | }
 58 | windowStack.prototype.dragEnable = function (event) {
 59 | 	var elementAt = document.elementFromPoint(event.clientX, event.clientY);
 60 | 	this.leftPos = this.getStyleFloatOf("left", "left");
 61 | 	this.topPos = this.getStyleFloatOf("top", "top");
 62 | 	var highX = this.leftPos + this.domObject.offsetWidth - document.documentElement.scrollLeft - document.getElementsByTagName("body")[0].scrollLeft;
 63 | 	var highY = this.topPos + this.domObject.offsetHeight - document.documentElement.scrollTop - document.getElementsByTagName("body")[0].scrollTop;
 64 | 	var mousedWindow = isSameNode(elementAt, this.domObject);
 65 | 	this.mousedInsideWindow = (mousedWindow) ? false : isDescendantOf(this.domObject, elementAt);
 66 | 	if (mousedWindow || this.mousedInsideWindow) {
 67 | 		this.movable = true;
 68 | 		this.leftLast = event.clientX;
 69 | 		this.topLast = event.clientY;
 70 | 		this.domObject.style.zIndex = 2;
 71 | 		if (highX - this.leftLast < 25 && highY - this.topLast < 25) {	/*Inivisible resize corner area for windows.*/
 72 | 			this.resize = true;
 73 | 		}
 74 | 		else {
 75 | 			this.resize = false;
 76 | 		}
 77 | 		this.coordDiffLeft = this.leftLast - this.leftPos;
 78 | 		this.coordDiffTop = this.topLast - this.topPos;
 79 | 		this.lastLeft = 0;
 80 | 		this.lastTop = 0;
 81 | 	}
 82 | 	else {
 83 | 		this.lostFocus();
 84 | 	}
 85 | }
 86 | windowStack.prototype.drag = function (event) {
 87 | 	if (this.movable) {
 88 | 		this.lastLeft += event.clientX - this.coordDiffLeft;
 89 | 		this.lastTop += event.clientY - this.coordDiffTop;
 90 | 		if (this.resize) {
 91 | 			var newWidth = this.domObject.clientWidth + event.clientX - this.leftLast - this.getStyleFloatOf("padding-left", "paddingLeft") - this.getStyleFloatOf("padding-right", "paddingRight");
 92 | 			var newHeight = this.domObject.clientHeight + event.clientY - this.topLast - this.getStyleFloatOf("padding-top", "paddingTop") - this.getStyleFloatOf("padding-bottom", "paddingBottom");
 93 | 			if (this.getStyleFloatOf("min-width", "minWidth") <= newWidth && this.getStyleFloatOf("min-height", "minHeight") <= newHeight && ((this.getStyleFloatOf("max-width", "maxWidth") >= newWidth || this.getStyleFloatOf("max-width", "maxWidth") == 0) && (this.getStyleFloatOf("max-height", "maxHeight") >= newHeight || this.getStyleFloatOf("max-height", "maxHeight") == 0))) {
 94 | 				this.domObject.style.width = newWidth + "px";
 95 | 				this.domObject.style.height = newHeight + "px";
 96 | 			}
 97 | 		}
 98 | 		else if (!this.mousedInsideWindow) {
 99 | 			this.domObject.style.left = this.lastLeft + "px";
100 | 			this.domObject.style.top = this.lastTop + "px";
101 | 		}
102 | 		this.coordDiffLeft = this.leftLast = event.clientX;
103 | 		this.coordDiffTop = this.topLast = event.clientY;
104 | 	}
105 | }
106 | windowStack.prototype.dragDisable = function () {
107 | 	this.movable = false;
108 | 	this.hadFocus = true;
109 | }
110 | windowStack.prototype.lostFocus = function () {
111 | 	if (this.hadFocus) {
112 | 		this.domObject.style.zIndex = 1;
113 | 		this.hadFocus = false;
114 | 	}
115 | }
116 | windowStack.prototype.interceptOpacity = function () {
117 | 	if (this.lastOpacity != null) {
118 | 		this.lastOpacity.bDoneRun = true;
119 | 		return this.lastOpacity.RefOpacityAREABegin;
120 | 	}
121 | 	var sampledOpacity = this.getStyleFloatOf("opacity", "opacity") * 100;
122 | 	return (sampledOpacity > 0) ? sampledOpacity : 100;	/*Dirty opacity first-set for IE*/
123 | }
124 | windowStack.prototype.center = function () {
125 | 	var docWidth = Math.max(document.documentElement.clientWidth, document.getElementsByTagName("body")[0].clientWidth);
126 | 	var docHeight = Math.max(document.documentElement.clientHeight, document.getElementsByTagName("body")[0].clientHeight);
127 | 	var docLeft = Math.max(document.documentElement.scrollLeft, document.getElementsByTagName("body")[0].scrollLeft);
128 | 	var docTop = Math.max(document.documentElement.scrollTop, document.getElementsByTagName("body")[0].scrollTop);
129 | 	this.domObject.style.left = Math.round(((docWidth - this.domObject.offsetWidth) / 2) + docLeft) + "px";
130 | 	this.domObject.style.top = Math.round(((docHeight - this.domObject.offsetHeight) / 2) + docTop) + "px";
131 | }
132 | windowStack.prototype.hide = function () {
133 | 	this.domObject.style.display = "none";
134 | 	this.unregisterMouseEvents();
135 | }
136 | windowStack.prototype.show = function () {
137 | 	this.domObject.style.display = "block";
138 | 	this.registerMouseEvents();
139 | }
140 | function popupMenu(oClick, oMenu) {
141 | 	this.clickElement = oClick;
142 | 	this.menuElement = oMenu;
143 | 	var thisObj2 = this;
144 | 	this.eventHandle = [
145 | 		function (event) { thisObj2.startPopup(event); },
146 | 		function (event) { thisObj2.endPopup(event); }
147 | 	];
148 | 	this.open = false;
149 | 	addEvent("click", this.clickElement, this.eventHandle[0]);
150 | }
151 | popupMenu.prototype.startPopup = function (event) {
152 | 	if (!this.open) {
153 | 		this.open = true;
154 | 		this.menuElement.style.display = "block";
155 | 		removeEvent("click", this.clickElement, this.eventHandle[0]);
156 | 		this.position(event);
157 | 		addEvent("mouseout", this.menuElement, this.eventHandle[1]);
158 | 	}
159 | }
160 | popupMenu.prototype.endPopup = function (event) {
161 | 	if (this.open) {
162 | 		if (mouseLeaveVerify(this.menuElement, event)) {
163 | 			this.open = false;
164 | 			this.menuElement.style.display = "none";
165 | 			removeEvent("mouseout", this.menuElement, this.eventHandle[1]);
166 | 			addEvent("click", this.clickElement, this.eventHandle[0]);
167 | 		}
168 | 	}
169 | }
170 | popupMenu.prototype.position = function (event) {
171 | 	if (this.open) {
172 | 		this.menuElement.style.left = (pageXCoord(event) - 5) + "px";
173 | 		this.menuElement.style.top = (pageYCoord(event) - 5) + "px";
174 | 	}
175 | }


--------------------------------------------------------------------------------
/manifest.webapp:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "GAMEBOY",
 3 |   "description": "GameBoy Online GAMEBOY Emulator",
 4 |   "launch_path": "/mobile.html",
 5 |   "fullscreen": true,
 6 |   "icons": {
 7 |     "128": "/images/128.png"
 8 |   },
 9 |   "orientation": ["portrait-primary"]
10 | }
11 | 


--------------------------------------------------------------------------------
/mobile.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width, user-scalable=no">
 6 |     <link rel="stylesheet" href="css/mobile.css"/>
 7 |   </head>
 8 |   <body>
 9 |     <!--reference: http://upload.wikimedia.org/wikipedia/commons/9/93/Game_boy_pocket.png-->
10 |     <div id="gameboy_shell">
11 |       <span id="on_off">OFF ! ! ON</span>
12 |       <div id="screen_cover">
13 |         <div id="power">
14 |           <div class="two_column">
15 |             <div id="power_light"></div>
16 |             <div>)))</div>
17 |           </div>
18 |           POWER
19 |         </div>
20 |         <div id="canvas_container">
21 |           <canvas id="mainCanvas">No Canvas Support</canvas>
22 |         </div>
23 |         <div>
24 |           GameBoy <span id="pocket">Pocket</span>
25 |         </div>
26 |       </div>
27 |       <div id="nintendo">Nintendo</div>
28 |       <div id="d_pad">
29 |         <div id="d_pad_up">
30 |           <div id="arrow_up" data-key-zone="up"></div>
31 |         </div>
32 |         <div id="d_pad_left_right">
33 |           <div id="d_pad_left">
34 |             <div id="arrow_left" data-key-zone="left"></div>
35 |           </div>
36 |           <div id="d_pad_right">
37 |             <div id="arrow_right" data-key-zone="right"></div>
38 |           </div>
39 |           <div id="d_pad_center"></div>
40 |         </div>
41 |         <div id="d_pad_down">
42 |           <div id="arrow_down" data-key-zone="down"></div>
43 |         </div>
44 |       </div>
45 |       <div id="a_button_group" class="button_group" data-key-zone="a">
46 |         <div class="round_button"></div>
47 |         A
48 |       </div>
49 |       <div id="b_button_group" class="button_group" data-key-zone="b">
50 |         <div class="round_button"></div>
51 |         B
52 |       </div>
53 |       <div id="select_button_group" class="button_group" data-key-zone="select">
54 |         <div class="flat_button"></div>
55 |         SELECT
56 |       </div>
57 |       <div id="start_button_group" class="button_group" data-key-zone="start">
58 |         <div class="flat_button"></div>
59 |         START
60 |       </div>
61 |       <img id="speaker" src="images/speaker.png"/>
62 |     </div>
63 |     <!--<script src="js/other/windowStack.js"></script>-->
64 |     <!--<script src="js/other/terminal.js"></script>-->
65 |     <script src="js/other/mobile.js"></script>
66 |     <script src="js/other/base64.js"></script>
67 |     <script src="js/other/json2.js"></script>
68 |     <script src="js/other/swfobject.js"></script>
69 |     <script src="js/other/resampler.js"></script>
70 |     <script src="js/other/XAudioServer.js"></script>
71 |     <script src="js/other/resize.js"></script>
72 |     <script src="js/GameBoyCore.js"></script>
73 |     <script src="js/GameBoyIO.js"></script>
74 |   </body>
75 | </html>
76 | 


--------------------------------------------------------------------------------