summaryrefslogtreecommitdiffstats
path: root/js/src/octane/gbemu-part1.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/octane/gbemu-part1.js')
-rw-r--r--js/src/octane/gbemu-part1.js1350
1 files changed, 1350 insertions, 0 deletions
diff --git a/js/src/octane/gbemu-part1.js b/js/src/octane/gbemu-part1.js
new file mode 100644
index 000000000..10f19e4a1
--- /dev/null
+++ b/js/src/octane/gbemu-part1.js
@@ -0,0 +1,1350 @@
+// Portions copyright 2013 Google, Inc
+
+// Copyright (C) 2010 - 2012 Grant Galitz
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation.
+// The full license is available at http://www.gnu.org/licenses/gpl.html
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+
+// The code has been adapted for use as a benchmark by Google.
+
+var GameboyBenchmark = new BenchmarkSuite('Gameboy', [26288412],
+ [new Benchmark('Gameboy',
+ false,
+ false,
+ 20,
+ runGameboy,
+ setupGameboy,
+ tearDownGameboy,
+ null,
+ 4)]);
+
+var decoded_gameboy_rom = null;
+
+function setupGameboy() {
+
+ // Check if all the types required by the code are supported.
+ // If not, throw exception and quit.
+ if (!(typeof Uint8Array != "undefined" &&
+ typeof Int8Array != "undefined" &&
+ typeof Float32Array != "undefined" &&
+ typeof Int32Array != "undefined") ) {
+ throw "TypedArrayUnsupported";
+ }
+ decoded_gameboy_rom = base64_decode(gameboy_rom);
+ rom = null;
+}
+
+function runGameboy() {
+ start(new GameBoyCanvas(), decoded_gameboy_rom);
+
+ gameboy.instructions = 0;
+ gameboy.totalInstructions = 250000;
+
+ while (gameboy.instructions <= gameboy.totalInstructions) {
+ gameboy.run();
+ GameBoyAudioNode.run();
+ }
+
+ resetGlobalVariables();
+}
+
+function tearDownGameboy() {
+ decoded_gameboy_rom = null;
+ expectedGameboyStateStr = null;
+}
+
+var expectedGameboyStateStr =
+ '{"registerA":160,"registerB":255,"registerC":255,"registerE":11,' +
+ '"registersHL":51600,"programCounter":24309,"stackPointer":49706,' +
+ '"sumROM":10171578,"sumMemory":3435856,"sumMBCRam":234598,"sumVRam":0}';
+
+// Start of browser emulation.
+
+var GameBoyWindow = { };
+
+function GameBoyContext() {
+ this.createBuffer = function() {
+ return new Buffer();
+ }
+ this.createImageData = function (w, h) {
+ var result = {};
+ // The following line was updated since Octane 1.0 to avoid OOB access.
+ result.data = new Uint8Array(w * h * 4);
+ return result;
+ }
+ this.putImageData = function (buffer, x, y) {
+ var sum = 0;
+ for (var i = 0; i < buffer.data.length; i++) {
+ sum += i * buffer.data[i];
+ sum = sum % 1000;
+ }
+ }
+ this.drawImage = function () { }
+};
+
+function GameBoyCanvas() {
+ this.getContext = function() {
+ return new GameBoyContext();
+ }
+ this.width = 160;
+ this.height = 144;
+ this.style = { visibility: "visibile" };
+}
+
+function cout(message, colorIndex) {
+}
+
+function clear_terminal() {
+}
+
+var GameBoyAudioNode = {
+ bufferSize : 0,
+ onaudioprocess : null ,
+ connect : function () {},
+ run: function() {
+ var event = {outputBuffer : this.outputBuffer};
+ this.onaudioprocess(event);
+ }
+};
+
+function GameBoyAudioContext () {
+ this.createBufferSource = function() {
+ return { noteOn : function () {}, connect : function() {}};
+ }
+ this.sampleRate = 48000;
+ this.destination = {}
+ this.createBuffer = function (channels, len, sampleRate) {
+ return { gain : 1,
+ numberOfChannels : 1,
+ length : 1,
+ duration : 0.000020833333110203966,
+ sampleRate : 48000}
+ }
+ this.createJavaScriptNode = function (bufferSize, inputChannels, outputChannels) {
+ GameBoyAudioNode.bufferSize = bufferSize;
+ GameBoyAudioNode.outputBuffer = {
+ getChannelData : function (i) {return this.channelData[i];},
+ channelData : []
+ };
+ for (var i = 0; i < outputChannels; i++) {
+ GameBoyAudioNode.outputBuffer.channelData[i] = new Float32Array(bufferSize);
+ }
+ return GameBoyAudioNode;
+ }
+}
+
+var mock_date_time_counter = 0;
+
+function new_Date() {
+ return {
+ getTime: function() {
+ mock_date_time_counter += 16;
+ return mock_date_time_counter;
+ }
+ };
+}
+
+// End of browser emulation.
+
+// Start of helper functions.
+
+function checkFinalState() {
+ function sum(a) {
+ var result = 0;
+ for (var i = 0; i < a.length; i++) {
+ result += a[i];
+ }
+ return result;
+ }
+ var state = {
+ registerA: gameboy.registerA,
+ registerB: gameboy.registerB,
+ registerC: gameboy.registerC,
+ registerE: gameboy.registerE,
+ registerF: gameboy.registerF,
+ registersHL: gameboy.registersHL,
+ programCounter: gameboy.programCounter,
+ stackPointer: gameboy.stackPointer,
+ sumROM : sum(gameboy.fromTypedArray(gameboy.ROM)),
+ sumMemory: sum(gameboy.fromTypedArray(gameboy.memory)),
+ sumMBCRam: sum(gameboy.fromTypedArray(gameboy.MBCRam)),
+ sumVRam: sum(gameboy.fromTypedArray(gameboy.VRam))
+ };
+ var expectedState = JSON.parse(expectedGameboyStateStr);
+ for (var prop in expectedState) {
+ if (state[prop] !== expectedState[prop]) {
+ var stateStr = JSON.stringify(state);
+ alert("Incorrect final state of processor:\n" +
+ " actual " + stateStr + "\n" +
+ " expected " + expectedGameboyStateStr);
+ }
+ }
+}
+
+
+function resetGlobalVariables () {
+ //Audio API Event Handler:
+ audioContextHandle = null;
+ audioNode = null;
+ audioSource = null;
+ launchedContext = false;
+ audioContextSampleBuffer = [];
+ resampled = [];
+ webAudioMinBufferSize = 15000;
+ webAudioMaxBufferSize = 25000;
+ webAudioActualSampleRate = 44100;
+ XAudioJSSampleRate = 0;
+ webAudioMono = false;
+ XAudioJSVolume = 1;
+ resampleControl = null;
+ audioBufferSize = 0;
+ resampleBufferStart = 0;
+ resampleBufferEnd = 0;
+ resampleBufferSize = 2;
+
+ gameboy = null; //GameBoyCore object.
+ gbRunInterval = null; //GameBoyCore Timer
+}
+
+
+// End of helper functions.
+
+// Original code from Grant Galitz follows.
+// Modifications by Google are marked in comments.
+
+// Start of js/other/base64.js file.
+
+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",
+ "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",
+ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+" , "/", "="];
+var fromBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+function base64(data) {
+ try {
+ // The following line was modified for benchmarking:
+ var base64 = GameBoyWindow.btoa(data); //Use this native function when it's available, as it's a magnitude faster than the non-native code below.
+ }
+ catch (error) {
+ //Defaulting to non-native base64 encoding...
+ var base64 = "";
+ var dataLength = data.length;
+ if (dataLength > 0) {
+ var bytes = [0, 0, 0];
+ var index = 0;
+ var remainder = dataLength % 3;
+ while (data.length % 3 > 0) {
+ //Make sure we don't do fuzzy math in the next loop...
+ data[data.length] = " ";
+ }
+ while (index < dataLength) {
+ //Keep this loop small for speed.
+ bytes = [data.charCodeAt(index++) & 0xFF, data.charCodeAt(index++) & 0xFF, data.charCodeAt(index++) & 0xFF];
+ 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];
+ }
+ if (remainder > 0) {
+ //Fill in the padding and recalulate the trailing six-bit group...
+ base64[base64.length - 1] = "=";
+ if (remainder == 2) {
+ base64[base64.length - 2] = "=";
+ base64[base64.length - 3] = toBase64[(bytes[0] & 0x3) << 4];
+ }
+ else {
+ base64[base64.length - 2] = toBase64[(bytes[1] & 0xF) << 2];
+ }
+ }
+ }
+ }
+ return base64;
+}
+function base64_decode(data) {
+ try {
+ // The following line was modified for benchmarking:
+ var decode64 = GameBoyWindow.atob(data); //Use this native function when it's available, as it's a magnitude faster than the non-native code below.
+ }
+ catch (error) {
+ //Defaulting to non-native base64 decoding...
+ var decode64 = "";
+ var dataLength = data.length;
+ if (dataLength > 3 && dataLength % 4 == 0) {
+ var sixbits = [0, 0, 0, 0]; //Declare this out of the loop, to speed up the ops.
+ var index = 0;
+ while (index < dataLength) {
+ //Keep this loop small for speed.
+ sixbits = [fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++)), fromBase64.indexOf(data.charAt(index++))];
+ 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]);
+ }
+ //Check for the '=' character after the loop, so we don't hose it up.
+ if (sixbits[3] >= 0x40) {
+ decode64.length -= 1;
+ if (sixbits[2] >= 0x40) {
+ decode64.length -= 1;
+ }
+ }
+ }
+ }
+ return decode64;
+}
+function to_little_endian_dword(str) {
+ return to_little_endian_word(str) + String.fromCharCode((str >> 16) & 0xFF, (str >> 24) & 0xFF);
+}
+function to_little_endian_word(str) {
+ return to_byte(str) + String.fromCharCode((str >> 8) & 0xFF);
+}
+function to_byte(str) {
+ return String.fromCharCode(str & 0xFF);
+}
+function arrayToBase64(arrayIn) {
+ var binString = "";
+ var length = arrayIn.length;
+ for (var index = 0; index < length; ++index) {
+ if (typeof arrayIn[index] == "number") {
+ binString += String.fromCharCode(arrayIn[index]);
+ }
+ }
+ return base64(binString);
+}
+function base64ToArray(b64String) {
+ var binString = base64_decode(b64String);
+ var outArray = [];
+ var length = binString.length;
+ for (var index = 0; index < length;) {
+ outArray.push(binString.charCodeAt(index++) & 0xFF);
+ }
+ return outArray;
+}
+
+// End of js/other/base64.js file.
+
+// Start of js/other/resampler.js file.
+
+//JavaScript Audio Resampler (c) 2011 - Grant Galitz
+function Resampler(fromSampleRate, toSampleRate, channels, outputBufferSize, noReturn) {
+ this.fromSampleRate = fromSampleRate;
+ this.toSampleRate = toSampleRate;
+ this.channels = channels | 0;
+ this.outputBufferSize = outputBufferSize;
+ this.noReturn = !!noReturn;
+ this.initialize();
+}
+Resampler.prototype.initialize = function () {
+ //Perform some checks:
+ if (this.fromSampleRate > 0 && this.toSampleRate > 0 && this.channels > 0) {
+ if (this.fromSampleRate == this.toSampleRate) {
+ //Setup a resampler bypass:
+ this.resampler = this.bypassResampler; //Resampler just returns what was passed through.
+ this.ratioWeight = 1;
+ }
+ else {
+ //Setup the interpolation resampler:
+ this.compileInterpolationFunction();
+ this.resampler = this.interpolate; //Resampler is a custom quality interpolation algorithm.
+ this.ratioWeight = this.fromSampleRate / this.toSampleRate;
+ this.tailExists = false;
+ this.lastWeight = 0;
+ this.initializeBuffers();
+ }
+ }
+ else {
+ throw(new Error("Invalid settings specified for the resampler."));
+ }
+}
+Resampler.prototype.compileInterpolationFunction = function () {
+ var toCompile = "var bufferLength = Math.min(buffer.length, this.outputBufferSize);\
+ if ((bufferLength % " + this.channels + ") == 0) {\
+ if (bufferLength > 0) {\
+ var ratioWeight = this.ratioWeight;\
+ var weight = 0;";
+ for (var channel = 0; channel < this.channels; ++channel) {
+ toCompile += "var output" + channel + " = 0;"
+ }
+ toCompile += "var actualPosition = 0;\
+ var amountToNext = 0;\
+ var alreadyProcessedTail = !this.tailExists;\
+ this.tailExists = false;\
+ var outputBuffer = this.outputBuffer;\
+ var outputOffset = 0;\
+ var currentPosition = 0;\
+ do {\
+ if (alreadyProcessedTail) {\
+ weight = ratioWeight;";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "output" + channel + " = 0;"
+ }
+ toCompile += "}\
+ else {\
+ weight = this.lastWeight;";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "output" + channel + " = this.lastOutput[" + channel + "];"
+ }
+ toCompile += "alreadyProcessedTail = true;\
+ }\
+ while (weight > 0 && actualPosition < bufferLength) {\
+ amountToNext = 1 + actualPosition - currentPosition;\
+ if (weight >= amountToNext) {";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "output" + channel + " += buffer[actualPosition++] * amountToNext;"
+ }
+ toCompile += "currentPosition = actualPosition;\
+ weight -= amountToNext;\
+ }\
+ else {";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "output" + channel + " += buffer[actualPosition" + ((channel > 0) ? (" + " + channel) : "") + "] * weight;"
+ }
+ toCompile += "currentPosition += weight;\
+ weight = 0;\
+ break;\
+ }\
+ }\
+ if (weight == 0) {";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "outputBuffer[outputOffset++] = output" + channel + " / ratioWeight;"
+ }
+ toCompile += "}\
+ else {\
+ this.lastWeight = weight;";
+ for (channel = 0; channel < this.channels; ++channel) {
+ toCompile += "this.lastOutput[" + channel + "] = output" + channel + ";"
+ }
+ toCompile += "this.tailExists = true;\
+ break;\
+ }\
+ } while (actualPosition < bufferLength);\
+ return this.bufferSlice(outputOffset);\
+ }\
+ else {\
+ return (this.noReturn) ? 0 : [];\
+ }\
+ }\
+ else {\
+ throw(new Error(\"Buffer was of incorrect sample length.\"));\
+ }";
+ this.interpolate = Function("buffer", toCompile);
+}
+Resampler.prototype.bypassResampler = function (buffer) {
+ if (this.noReturn) {
+ //Set the buffer passed as our own, as we don't need to resample it:
+ this.outputBuffer = buffer;
+ return buffer.length;
+ }
+ else {
+ //Just return the buffer passsed:
+ return buffer;
+ }
+}
+Resampler.prototype.bufferSlice = function (sliceAmount) {
+ if (this.noReturn) {
+ //If we're going to access the properties directly from this object:
+ return sliceAmount;
+ }
+ else {
+ //Typed array and normal array buffer section referencing:
+ try {
+ return this.outputBuffer.subarray(0, sliceAmount);
+ }
+ catch (error) {
+ try {
+ //Regular array pass:
+ this.outputBuffer.length = sliceAmount;
+ return this.outputBuffer;
+ }
+ catch (error) {
+ //Nightly Firefox 4 used to have the subarray function named as slice:
+ return this.outputBuffer.slice(0, sliceAmount);
+ }
+ }
+ }
+}
+Resampler.prototype.initializeBuffers = function () {
+ //Initialize the internal buffer:
+ try {
+ this.outputBuffer = new Float32Array(this.outputBufferSize);
+ this.lastOutput = new Float32Array(this.channels);
+ }
+ catch (error) {
+ this.outputBuffer = [];
+ this.lastOutput = [];
+ }
+}
+
+// End of js/other/resampler.js file.
+
+// Start of js/other/XAudioServer.js file.
+
+/*Initialize here first:
+ Example:
+ Stereo audio with a sample rate of 70 khz, a minimum buffer of 15000 samples total, a maximum buffer of 25000 samples total and a starting volume level of 1.
+ var parentObj = this;
+ this.audioHandle = new XAudioServer(2, 70000, 15000, 25000, function (sampleCount) {
+ return parentObj.audioUnderRun(sampleCount);
+ }, 1);
+
+ The callback is passed the number of samples requested, while it can return any number of samples it wants back.
+*/
+function XAudioServer(channels, sampleRate, minBufferSize, maxBufferSize, underRunCallback, volume) {
+ this.audioChannels = (channels == 2) ? 2 : 1;
+ webAudioMono = (this.audioChannels == 1);
+ XAudioJSSampleRate = (sampleRate > 0 && sampleRate <= 0xFFFFFF) ? sampleRate : 44100;
+ webAudioMinBufferSize = (minBufferSize >= (samplesPerCallback << 1) && minBufferSize < maxBufferSize) ? (minBufferSize & ((webAudioMono) ? 0xFFFFFFFF : 0xFFFFFFFE)) : (samplesPerCallback << 1);
+ webAudioMaxBufferSize = (Math.floor(maxBufferSize) > webAudioMinBufferSize + this.audioChannels) ? (maxBufferSize & ((webAudioMono) ? 0xFFFFFFFF : 0xFFFFFFFE)) : (minBufferSize << 1);
+ this.underRunCallback = (typeof underRunCallback == "function") ? underRunCallback : function () {};
+ XAudioJSVolume = (volume >= 0 && volume <= 1) ? volume : 1;
+ this.audioType = -1;
+ this.mozAudioTail = [];
+ this.audioHandleMoz = null;
+ this.audioHandleFlash = null;
+ this.flashInitialized = false;
+ this.mozAudioFound = false;
+ this.initializeAudio();
+}
+XAudioServer.prototype.MOZWriteAudio = function (buffer) {
+ //mozAudio:
+ this.MOZWriteAudioNoCallback(buffer);
+ this.MOZExecuteCallback();
+}
+XAudioServer.prototype.MOZWriteAudioNoCallback = function (buffer) {
+ //mozAudio:
+ this.writeMozAudio(buffer);
+}
+XAudioServer.prototype.callbackBasedWriteAudio = function (buffer) {
+ //Callback-centered audio APIs:
+ this.callbackBasedWriteAudioNoCallback(buffer);
+ this.callbackBasedExecuteCallback();
+}
+XAudioServer.prototype.callbackBasedWriteAudioNoCallback = function (buffer) {
+ //Callback-centered audio APIs:
+ var length = buffer.length;
+ for (var bufferCounter = 0; bufferCounter < length && audioBufferSize < webAudioMaxBufferSize;) {
+ audioContextSampleBuffer[audioBufferSize++] = buffer[bufferCounter++];
+ }
+}
+/*Pass your samples into here!
+Pack your samples as a one-dimenional array
+With the channel samplea packed uniformly.
+examples:
+ mono - [left, left, left, left]
+ stereo - [left, right, left, right, left, right, left, right]
+*/
+XAudioServer.prototype.writeAudio = function (buffer) {
+ if (this.audioType == 0) {
+ this.MOZWriteAudio(buffer);
+ }
+ else if (this.audioType == 1) {
+ this.callbackBasedWriteAudio(buffer);
+ }
+ else if (this.audioType == 2) {
+ if (this.checkFlashInit() || launchedContext) {
+ this.callbackBasedWriteAudio(buffer);
+ }
+ else if (this.mozAudioFound) {
+ this.MOZWriteAudio(buffer);
+ }
+ }
+}
+/*Pass your samples into here if you don't want automatic callback calling:
+Pack your samples as a one-dimenional array
+With the channel samplea packed uniformly.
+examples:
+ mono - [left, left, left, left]
+ stereo - [left, right, left, right, left, right, left, right]
+Useful in preventing infinite recursion issues with calling writeAudio inside your callback.
+*/
+XAudioServer.prototype.writeAudioNoCallback = function (buffer) {
+ if (this.audioType == 0) {
+ this.MOZWriteAudioNoCallback(buffer);
+ }
+ else if (this.audioType == 1) {
+ this.callbackBasedWriteAudioNoCallback(buffer);
+ }
+ else if (this.audioType == 2) {
+ if (this.checkFlashInit() || launchedContext) {
+ this.callbackBasedWriteAudioNoCallback(buffer);
+ }
+ else if (this.mozAudioFound) {
+ this.MOZWriteAudioNoCallback(buffer);
+ }
+ }
+}
+//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...)
+//If -1 is returned, then that means metric could not be done.
+XAudioServer.prototype.remainingBuffer = function () {
+ if (this.audioType == 0) {
+ //mozAudio:
+ return this.samplesAlreadyWritten - this.audioHandleMoz.mozCurrentSampleOffset();
+ }
+ else if (this.audioType == 1) {
+ //WebKit Audio:
+ return (((resampledSamplesLeft() * resampleControl.ratioWeight) >> (this.audioChannels - 1)) << (this.audioChannels - 1)) + audioBufferSize;
+ }
+ else if (this.audioType == 2) {
+ if (this.checkFlashInit() || launchedContext) {
+ //Webkit Audio / Flash Plugin Audio:
+ return (((resampledSamplesLeft() * resampleControl.ratioWeight) >> (this.audioChannels - 1)) << (this.audioChannels - 1)) + audioBufferSize;
+ }
+ else if (this.mozAudioFound) {
+ //mozAudio:
+ return this.samplesAlreadyWritten - this.audioHandleMoz.mozCurrentSampleOffset();
+ }
+ }
+ //Default return:
+ return 0;
+}
+XAudioServer.prototype.MOZExecuteCallback = function () {
+ //mozAudio:
+ var samplesRequested = webAudioMinBufferSize - this.remainingBuffer();
+ if (samplesRequested > 0) {
+ this.writeMozAudio(this.underRunCallback(samplesRequested));
+ }
+}
+XAudioServer.prototype.callbackBasedExecuteCallback = function () {
+ //WebKit /Flash Audio:
+ var samplesRequested = webAudioMinBufferSize - this.remainingBuffer();
+ if (samplesRequested > 0) {
+ this.callbackBasedWriteAudioNoCallback(this.underRunCallback(samplesRequested));
+ }
+}
+//If you just want your callback called for any possible refill (Execution of callback is still conditional):
+XAudioServer.prototype.executeCallback = function () {
+ if (this.audioType == 0) {
+ this.MOZExecuteCallback();
+ }
+ else if (this.audioType == 1) {
+ this.callbackBasedExecuteCallback();
+ }
+ else if (this.audioType == 2) {
+ if (this.checkFlashInit() || launchedContext) {
+ this.callbackBasedExecuteCallback();
+ }
+ else if (this.mozAudioFound) {
+ this.MOZExecuteCallback();
+ }
+ }
+}
+//DO NOT CALL THIS, the lib calls this internally!
+XAudioServer.prototype.initializeAudio = function () {
+ try {
+ throw (new Error("Select initializeWebAudio case")); // Line added for benchmarking.
+ this.preInitializeMozAudio();
+ if (navigator.platform == "Linux i686") {
+ //Block out mozaudio usage for Linux Firefox due to moz bugs:
+ throw(new Error(""));
+ }
+ this.initializeMozAudio();
+ }
+ catch (error) {
+ try {
+ this.initializeWebAudio();
+ }
+ catch (error) {
+ try {
+ this.initializeFlashAudio();
+ }
+ catch (error) {
+ throw(new Error("Browser does not support real time audio output."));
+ }
+ }
+ }
+}
+XAudioServer.prototype.preInitializeMozAudio = function () {
+ //mozAudio - Synchronous Audio API
+ this.audioHandleMoz = new Audio();
+ this.audioHandleMoz.mozSetup(this.audioChannels, XAudioJSSampleRate);
+ this.samplesAlreadyWritten = 0;
+ var emptySampleFrame = (this.audioChannels == 2) ? [0, 0] : [0];
+ var prebufferAmount = 0;
+ if (navigator.platform != "MacIntel" && navigator.platform != "MacPPC") { //Mac OS X doesn't experience this moz-bug!
+ while (this.audioHandleMoz.mozCurrentSampleOffset() == 0) {
+ //Mozilla Audio Bugginess Workaround (Firefox freaks out if we don't give it a prebuffer under certain OSes):
+ prebufferAmount += this.audioHandleMoz.mozWriteAudio(emptySampleFrame);
+ }
+ var samplesToDoubleBuffer = prebufferAmount / this.audioChannels;
+ //Double the prebuffering for windows:
+ for (var index = 0; index < samplesToDoubleBuffer; index++) {
+ this.samplesAlreadyWritten += this.audioHandleMoz.mozWriteAudio(emptySampleFrame);
+ }
+ }
+ this.samplesAlreadyWritten += prebufferAmount;
+ webAudioMinBufferSize += this.samplesAlreadyWritten;
+ this.mozAudioFound = true;
+}
+XAudioServer.prototype.initializeMozAudio = function () {
+ //Fill in our own buffering up to the minimum specified:
+ this.writeMozAudio(getFloat32(webAudioMinBufferSize));
+ this.audioType = 0;
+}
+XAudioServer.prototype.initializeWebAudio = function () {
+ if (launchedContext) {
+ resetCallbackAPIAudioBuffer(webAudioActualSampleRate, samplesPerCallback);
+ this.audioType = 1;
+ }
+ else {
+ throw(new Error(""));
+ }
+}
+XAudioServer.prototype.initializeFlashAudio = function () {
+ var existingFlashload = document.getElementById("XAudioJS");
+ if (existingFlashload == null) {
+ var thisObj = this;
+ var mainContainerNode = document.createElement("div");
+ mainContainerNode.setAttribute("style", "position: fixed; bottom: 0px; right: 0px; margin: 0px; padding: 0px; border: none; width: 8px; height: 8px; overflow: hidden; z-index: -1000; ");
+ var containerNode = document.createElement("div");
+ containerNode.setAttribute("style", "position: static; border: none; width: 0px; height: 0px; visibility: hidden; margin: 8px; padding: 0px;");
+ containerNode.setAttribute("id", "XAudioJS");
+ mainContainerNode.appendChild(containerNode);
+ document.getElementsByTagName("body")[0].appendChild(mainContainerNode);
+ swfobject.embedSWF(
+ "XAudioJS.swf",
+ "XAudioJS",
+ "8",
+ "8",
+ "9.0.0",
+ "",
+ {},
+ {"allowscriptaccess":"always"},
+ {"style":"position: static; visibility: hidden; margin: 8px; padding: 0px; border: none"},
+ function (event) {
+ if (event.success) {
+ thisObj.audioHandleFlash = event.ref;
+ }
+ else {
+ thisObj.audioType = 1;
+ }
+ }
+ );
+ }
+ else {
+ this.audioHandleFlash = existingFlashload;
+ }
+ this.audioType = 2;
+}
+XAudioServer.prototype.changeVolume = function (newVolume) {
+ if (newVolume >= 0 && newVolume <= 1) {
+ XAudioJSVolume = newVolume;
+ if (this.checkFlashInit()) {
+ this.audioHandleFlash.changeVolume(XAudioJSVolume);
+ }
+ if (this.mozAudioFound) {
+ this.audioHandleMoz.volume = XAudioJSVolume;
+ }
+ }
+}
+//Moz Audio Buffer Writing Handler:
+XAudioServer.prototype.writeMozAudio = function (buffer) {
+ var length = this.mozAudioTail.length;
+ if (length > 0) {
+ var samplesAccepted = this.audioHandleMoz.mozWriteAudio(this.mozAudioTail);
+ this.samplesAlreadyWritten += samplesAccepted;
+ this.mozAudioTail.splice(0, samplesAccepted);
+ }
+ length = Math.min(buffer.length, webAudioMaxBufferSize - this.samplesAlreadyWritten + this.audioHandleMoz.mozCurrentSampleOffset());
+ var samplesAccepted = this.audioHandleMoz.mozWriteAudio(buffer);
+ this.samplesAlreadyWritten += samplesAccepted;
+ for (var index = 0; length > samplesAccepted; --length) {
+ //Moz Audio wants us saving the tail:
+ this.mozAudioTail.push(buffer[index++]);
+ }
+}
+//Checks to see if the NPAPI Adobe Flash bridge is ready yet:
+XAudioServer.prototype.checkFlashInit = function () {
+ if (!this.flashInitialized && this.audioHandleFlash && this.audioHandleFlash.initialize) {
+ this.flashInitialized = true;
+ this.audioHandleFlash.initialize(this.audioChannels, XAudioJSVolume);
+ resetCallbackAPIAudioBuffer(44100, samplesPerCallback);
+ }
+ return this.flashInitialized;
+}
+/////////END LIB
+function getFloat32(size) {
+ try {
+ return new Float32Array(size);
+ }
+ catch (error) {
+ return new Array(size);
+ }
+}
+function getFloat32Flat(size) {
+ try {
+ var newBuffer = new Float32Array(size);
+ }
+ catch (error) {
+ var newBuffer = new Array(size);
+ var audioSampleIndice = 0;
+ do {
+ newBuffer[audioSampleIndice] = 0;
+ } while (++audioSampleIndice < size);
+ }
+ return newBuffer;
+}
+//Flash NPAPI Event Handler:
+var samplesPerCallback = 2048; //Has to be between 2048 and 4096 (If over, then samples are ignored, if under then silence is added).
+var outputConvert = null;
+function audioOutputFlashEvent() { //The callback that flash calls...
+ resampleRefill();
+ return outputConvert();
+}
+function generateFlashStereoString() { //Convert the arrays to one long string for speed.
+ var copyBinaryStringLeft = "";
+ var copyBinaryStringRight = "";
+ for (var index = 0; index < samplesPerCallback && resampleBufferStart != resampleBufferEnd; ++index) {
+ //Sanitize the buffer:
+ copyBinaryStringLeft += String.fromCharCode(((Math.min(Math.max(resampled[resampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
+ copyBinaryStringRight += String.fromCharCode(((Math.min(Math.max(resampled[resampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
+ if (resampleBufferStart == resampleBufferSize) {
+ resampleBufferStart = 0;
+ }
+ }
+ return copyBinaryStringLeft + copyBinaryStringRight;
+}
+function generateFlashMonoString() { //Convert the array to one long string for speed.
+ var copyBinaryString = "";
+ for (var index = 0; index < samplesPerCallback && resampleBufferStart != resampleBufferEnd; ++index) {
+ //Sanitize the buffer:
+ copyBinaryString += String.fromCharCode(((Math.min(Math.max(resampled[resampleBufferStart++] + 1, 0), 2) * 0x3FFF) | 0) + 0x3000);
+ if (resampleBufferStart == resampleBufferSize) {
+ resampleBufferStart = 0;
+ }
+ }
+ return copyBinaryString;
+}
+//Audio API Event Handler:
+var audioContextHandle = null;
+var audioNode = null;
+var audioSource = null;
+var launchedContext = false;
+var audioContextSampleBuffer = [];
+var resampled = [];
+var webAudioMinBufferSize = 15000;
+var webAudioMaxBufferSize = 25000;
+var webAudioActualSampleRate = 44100;
+var XAudioJSSampleRate = 0;
+var webAudioMono = false;
+var XAudioJSVolume = 1;
+var resampleControl = null;
+var audioBufferSize = 0;
+var resampleBufferStart = 0;
+var resampleBufferEnd = 0;
+var resampleBufferSize = 2;
+function audioOutputEvent(event) { //Web Audio API callback...
+ var index = 0;
+ var buffer1 = event.outputBuffer.getChannelData(0);
+ var buffer2 = event.outputBuffer.getChannelData(1);
+ resampleRefill();
+ if (!webAudioMono) {
+ //STEREO:
+ while (index < samplesPerCallback && resampleBufferStart != resampleBufferEnd) {
+ buffer1[index] = resampled[resampleBufferStart++] * XAudioJSVolume;
+ buffer2[index++] = resampled[resampleBufferStart++] * XAudioJSVolume;
+ if (resampleBufferStart == resampleBufferSize) {
+ resampleBufferStart = 0;
+ }
+ }
+ }
+ else {
+ //MONO:
+ while (index < samplesPerCallback && resampleBufferStart != resampleBufferEnd) {
+ buffer2[index] = buffer1[index] = resampled[resampleBufferStart++] * XAudioJSVolume;
+ ++index;
+ if (resampleBufferStart == resampleBufferSize) {
+ resampleBufferStart = 0;
+ }
+ }
+ }
+ //Pad with silence if we're underrunning:
+ while (index < samplesPerCallback) {
+ buffer2[index] = buffer1[index] = 0;
+ ++index;
+ }
+}
+function resampleRefill() {
+ if (audioBufferSize > 0) {
+ //Resample a chunk of audio:
+ var resampleLength = resampleControl.resampler(getBufferSamples());
+ var resampledResult = resampleControl.outputBuffer;
+ for (var index2 = 0; index2 < resampleLength; ++index2) {
+ resampled[resampleBufferEnd++] = resampledResult[index2];
+ if (resampleBufferEnd == resampleBufferSize) {
+ resampleBufferEnd = 0;
+ }
+ if (resampleBufferStart == resampleBufferEnd) {
+ ++resampleBufferStart;
+ if (resampleBufferStart == resampleBufferSize) {
+ resampleBufferStart = 0;
+ }
+ }
+ }
+ audioBufferSize = 0;
+ }
+}
+function resampledSamplesLeft() {
+ return ((resampleBufferStart <= resampleBufferEnd) ? 0 : resampleBufferSize) + resampleBufferEnd - resampleBufferStart;
+}
+function getBufferSamples() {
+ //Typed array and normal array buffer section referencing:
+ try {
+ return audioContextSampleBuffer.subarray(0, audioBufferSize);
+ }
+ catch (error) {
+ try {
+ //Regular array pass:
+ audioContextSampleBuffer.length = audioBufferSize;
+ return audioContextSampleBuffer;
+ }
+ catch (error) {
+ //Nightly Firefox 4 used to have the subarray function named as slice:
+ return audioContextSampleBuffer.slice(0, audioBufferSize);
+ }
+ }
+}
+//Initialize WebKit Audio /Flash Audio Buffer:
+function resetCallbackAPIAudioBuffer(APISampleRate, bufferAlloc) {
+ audioContextSampleBuffer = getFloat32(webAudioMaxBufferSize);
+ audioBufferSize = webAudioMaxBufferSize;
+ resampleBufferStart = 0;
+ resampleBufferEnd = 0;
+ resampleBufferSize = Math.max(webAudioMaxBufferSize * Math.ceil(XAudioJSSampleRate / APISampleRate), samplesPerCallback) << 1;
+ if (webAudioMono) {
+ //MONO Handling:
+ resampled = getFloat32Flat(resampleBufferSize);
+ resampleControl = new Resampler(XAudioJSSampleRate, APISampleRate, 1, resampleBufferSize, true);
+ outputConvert = generateFlashMonoString;
+ }
+ else {
+ //STEREO Handling:
+ resampleBufferSize <<= 1;
+ resampled = getFloat32Flat(resampleBufferSize);
+ resampleControl = new Resampler(XAudioJSSampleRate, APISampleRate, 2, resampleBufferSize, true);
+ outputConvert = generateFlashStereoString;
+ }
+}
+//Initialize WebKit Audio:
+(function () {
+ if (!launchedContext) {
+ try {
+ // The following line was modified for benchmarking:
+ audioContextHandle = new GameBoyAudioContext(); //Create a system audio context.
+ }
+ catch (error) {
+ try {
+ audioContextHandle = new AudioContext(); //Create a system audio context.
+ }
+ catch (error) {
+ return;
+ }
+ }
+ try {
+ audioSource = audioContextHandle.createBufferSource(); //We need to create a false input to get the chain started.
+ audioSource.loop = false; //Keep this alive forever (Event handler will know when to ouput.)
+ XAudioJSSampleRate = webAudioActualSampleRate = audioContextHandle.sampleRate;
+ audioSource.buffer = audioContextHandle.createBuffer(1, 1, webAudioActualSampleRate); //Create a zero'd input buffer for the input to be valid.
+ audioNode = audioContextHandle.createJavaScriptNode(samplesPerCallback, 1, 2); //Create 2 outputs and ignore the input buffer (Just copy buffer 1 over if mono)
+ audioNode.onaudioprocess = audioOutputEvent; //Connect the audio processing event to a handling function so we can manipulate output
+ audioSource.connect(audioNode); //Send and chain the input to the audio manipulation.
+ audioNode.connect(audioContextHandle.destination); //Send and chain the output of the audio manipulation to the system audio output.
+ audioSource.noteOn(0); //Start the loop!
+ }
+ catch (error) {
+ return;
+ }
+ launchedContext = true;
+ }
+})();
+
+// End of js/other/XAudioServer.js file.
+
+// Start of js/other/resize.js file.
+
+//JavaScript Image Resizer (c) 2012 - Grant Galitz
+function Resize(widthOriginal, heightOriginal, targetWidth, targetHeight, blendAlpha, interpolationPass) {
+ this.widthOriginal = Math.abs(parseInt(widthOriginal) || 0);
+ this.heightOriginal = Math.abs(parseInt(heightOriginal) || 0);
+ this.targetWidth = Math.abs(parseInt(targetWidth) || 0);
+ this.targetHeight = Math.abs(parseInt(targetHeight) || 0);
+ this.colorChannels = (!!blendAlpha) ? 4 : 3;
+ this.interpolationPass = !!interpolationPass;
+ this.targetWidthMultipliedByChannels = this.targetWidth * this.colorChannels;
+ this.originalWidthMultipliedByChannels = this.widthOriginal * this.colorChannels;
+ this.originalHeightMultipliedByChannels = this.heightOriginal * this.colorChannels;
+ this.widthPassResultSize = this.targetWidthMultipliedByChannels * this.heightOriginal;
+ this.finalResultSize = this.targetWidthMultipliedByChannels * this.targetHeight;
+ this.initialize();
+}
+Resize.prototype.initialize = function () {
+ //Perform some checks:
+ if (this.widthOriginal > 0 && this.heightOriginal > 0 && this.targetWidth > 0 && this.targetHeight > 0) {
+ if (this.widthOriginal == this.targetWidth) {
+ //Bypass the width resizer pass:
+ this.resizeWidth = this.bypassResizer;
+ }
+ else {
+ //Setup the width resizer pass:
+ this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
+ if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
+ this.initializeFirstPassBuffers(true);
+ this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthInterpolatedRGBA : this.resizeWidthInterpolatedRGB;
+ }
+ else {
+ this.initializeFirstPassBuffers(false);
+ this.resizeWidth = (this.colorChannels == 4) ? this.resizeWidthRGBA : this.resizeWidthRGB;
+ }
+ }
+ if (this.heightOriginal == this.targetHeight) {
+ //Bypass the height resizer pass:
+ this.resizeHeight = this.bypassResizer;
+ }
+ else {
+ //Setup the height resizer pass:
+ this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
+ if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
+ this.initializeSecondPassBuffers(true);
+ this.resizeHeight = this.resizeHeightInterpolated;
+ }
+ else {
+ this.initializeSecondPassBuffers(false);
+ this.resizeHeight = (this.colorChannels == 4) ? this.resizeHeightRGBA : this.resizeHeightRGB;
+ }
+ }
+ }
+ else {
+ throw(new Error("Invalid settings specified for the resizer."));
+ }
+}
+Resize.prototype.resizeWidthRGB = function (buffer) {
+ var ratioWeight = this.ratioWeightWidthPass;
+ var weight = 0;
+ var amountToNext = 0;
+ var actualPosition = 0;
+ var currentPosition = 0;
+ var line = 0;
+ var pixelOffset = 0;
+ var outputOffset = 0;
+ var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 2;
+ var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 2;
+ var output = this.outputWidthWorkBench;
+ var outputBuffer = this.widthBuffer;
+ do {
+ for (line = 0; line < this.originalHeightMultipliedByChannels;) {
+ output[line++] = 0;
+ output[line++] = 0;
+ output[line++] = 0;
+ }
+ weight = ratioWeight;
+ do {
+ amountToNext = 1 + actualPosition - currentPosition;
+ if (weight >= amountToNext) {
+ for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
+ output[line++] += buffer[pixelOffset++] * amountToNext;
+ output[line++] += buffer[pixelOffset++] * amountToNext;
+ output[line++] += buffer[pixelOffset] * amountToNext;
+ }
+ currentPosition = actualPosition = actualPosition + 3;
+ weight -= amountToNext;
+ }
+ else {
+ for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
+ output[line++] += buffer[pixelOffset++] * weight;
+ output[line++] += buffer[pixelOffset++] * weight;
+ output[line++] += buffer[pixelOffset] * weight;
+ }
+ currentPosition += weight;
+ break;
+ }
+ } while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
+ for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
+ outputBuffer[pixelOffset++] = output[line++] / ratioWeight;
+ outputBuffer[pixelOffset++] = output[line++] / ratioWeight;
+ outputBuffer[pixelOffset] = output[line++] / ratioWeight;
+ }
+ outputOffset += 3;
+ } while (outputOffset < this.targetWidthMultipliedByChannels);
+ return outputBuffer;
+}
+Resize.prototype.resizeWidthInterpolatedRGB = function (buffer) {
+ var ratioWeight = (this.widthOriginal - 1) / this.targetWidth;
+ var weight = 0;
+ var finalOffset = 0;
+ var pixelOffset = 0;
+ var outputBuffer = this.widthBuffer;
+ for (var targetPosition = 0; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 3, weight += ratioWeight) {
+ //Calculate weightings:
+ secondWeight = weight % 1;
+ firstWeight = 1 - secondWeight;
+ //Interpolate:
+ for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 3; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
+ outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 3] * secondWeight);
+ outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
+ outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
+ }
+ }
+ return outputBuffer;
+}
+Resize.prototype.resizeWidthRGBA = function (buffer) {
+ var ratioWeight = this.ratioWeightWidthPass;
+ var weight = 0;
+ var amountToNext = 0;
+ var actualPosition = 0;
+ var currentPosition = 0;
+ var line = 0;
+ var pixelOffset = 0;
+ var outputOffset = 0;
+ var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - 3;
+ var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - 3;
+ var output = this.outputWidthWorkBench;
+ var outputBuffer = this.widthBuffer;
+ do {
+ for (line = 0; line < this.originalHeightMultipliedByChannels;) {
+ output[line++] = 0;
+ output[line++] = 0;
+ output[line++] = 0;
+ output[line++] = 0;
+ }
+ weight = ratioWeight;
+ do {
+ amountToNext = 1 + actualPosition - currentPosition;
+ if (weight >= amountToNext) {
+ for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
+ output[line++] += buffer[pixelOffset++] * amountToNext;
+ output[line++] += buffer[pixelOffset++] * amountToNext;
+ output[line++] += buffer[pixelOffset++] * amountToNext;
+ output[line++] += buffer[pixelOffset] * amountToNext;
+ }
+ currentPosition = actualPosition = actualPosition + 4;
+ weight -= amountToNext;
+ }
+ else {
+ for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
+ output[line++] += buffer[pixelOffset++] * weight;
+ output[line++] += buffer[pixelOffset++] * weight;
+ output[line++] += buffer[pixelOffset++] * weight;
+ output[line++] += buffer[pixelOffset] * weight;
+ }
+ currentPosition += weight;
+ break;
+ }
+ } while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
+ for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
+ outputBuffer[pixelOffset++] = output[line++] / ratioWeight;
+ outputBuffer[pixelOffset++] = output[line++] / ratioWeight;
+ outputBuffer[pixelOffset++] = output[line++] / ratioWeight;
+ outputBuffer[pixelOffset] = output[line++] / ratioWeight;
+ }
+ outputOffset += 4;
+ } while (outputOffset < this.targetWidthMultipliedByChannels);
+ return outputBuffer;
+}
+Resize.prototype.resizeWidthInterpolatedRGBA = function (buffer) {
+ var ratioWeight = (this.widthOriginal - 1) / this.targetWidth;
+ var weight = 0;
+ var finalOffset = 0;
+ var pixelOffset = 0;
+ var outputBuffer = this.widthBuffer;
+ for (var targetPosition = 0; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += 4, weight += ratioWeight) {
+ //Calculate weightings:
+ secondWeight = weight % 1;
+ firstWeight = 1 - secondWeight;
+ //Interpolate:
+ for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * 4; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
+ outputBuffer[finalOffset] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
+ outputBuffer[finalOffset + 1] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
+ outputBuffer[finalOffset + 2] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 6] * secondWeight);
+ outputBuffer[finalOffset + 3] = (buffer[pixelOffset + 3] * firstWeight) + (buffer[pixelOffset + 7] * secondWeight);
+ }
+ }
+ return outputBuffer;
+}
+Resize.prototype.resizeHeightRGB = function (buffer) {
+ var ratioWeight = this.ratioWeightHeightPass;
+ var weight = 0;
+ var amountToNext = 0;
+ var actualPosition = 0;
+ var currentPosition = 0;
+ var pixelOffset = 0;
+ var outputOffset = 0;
+ var output = this.outputHeightWorkBench;
+ var outputBuffer = this.heightBuffer;
+ do {
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] = 0;
+ output[pixelOffset++] = 0;
+ output[pixelOffset++] = 0;
+ }
+ weight = ratioWeight;
+ do {
+ amountToNext = 1 + actualPosition - currentPosition;
+ if (weight >= amountToNext) {
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ }
+ currentPosition = actualPosition;
+ weight -= amountToNext;
+ }
+ else {
+ for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ }
+ currentPosition += weight;
+ break;
+ }
+ } while (weight > 0 && actualPosition < this.widthPassResultSize);
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ }
+ } while (outputOffset < this.finalResultSize);
+ return outputBuffer;
+}
+Resize.prototype.resizeHeightInterpolated = function (buffer) {
+ var ratioWeight = (this.heightOriginal - 1) / this.targetHeight;
+ var weight = 0;
+ var finalOffset = 0;
+ var pixelOffset = 0;
+ var pixelOffsetAccumulated = 0;
+ var pixelOffsetAccumulated2 = 0;
+ var outputBuffer = this.heightBuffer;
+ do {
+ //Calculate weightings:
+ secondWeight = weight % 1;
+ firstWeight = 1 - secondWeight;
+ //Interpolate:
+ pixelOffsetAccumulated = Math.floor(weight) * this.targetWidthMultipliedByChannels;
+ pixelOffsetAccumulated2 = pixelOffsetAccumulated + this.targetWidthMultipliedByChannels;
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
+ outputBuffer[finalOffset++] = (buffer[pixelOffsetAccumulated + pixelOffset] * firstWeight) + (buffer[pixelOffsetAccumulated2 + pixelOffset] * secondWeight);
+ }
+ weight += ratioWeight;
+ } while (finalOffset < this.finalResultSize);
+ return outputBuffer;
+}
+Resize.prototype.resizeHeightRGBA = function (buffer) {
+ var ratioWeight = this.ratioWeightHeightPass;
+ var weight = 0;
+ var amountToNext = 0;
+ var actualPosition = 0;
+ var currentPosition = 0;
+ var pixelOffset = 0;
+ var outputOffset = 0;
+ var output = this.outputHeightWorkBench;
+ var outputBuffer = this.heightBuffer;
+ do {
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] = 0;
+ output[pixelOffset++] = 0;
+ output[pixelOffset++] = 0;
+ output[pixelOffset++] = 0;
+ }
+ weight = ratioWeight;
+ do {
+ amountToNext = 1 + actualPosition - currentPosition;
+ if (weight >= amountToNext) {
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ output[pixelOffset++] += buffer[actualPosition++] * amountToNext;
+ }
+ currentPosition = actualPosition;
+ weight -= amountToNext;
+ }
+ else {
+ for (pixelOffset = 0, amountToNext = actualPosition; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ output[pixelOffset++] += buffer[amountToNext++] * weight;
+ }
+ currentPosition += weight;
+ break;
+ }
+ } while (weight > 0 && actualPosition < this.widthPassResultSize);
+ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] / ratioWeight);
+ }
+ } while (outputOffset < this.finalResultSize);
+ return outputBuffer;
+}
+Resize.prototype.resizeHeightInterpolatedRGBA = function (buffer) {
+ var ratioWeight = (this.heightOriginal - 1) / this.targetHeight;
+ var weight = 0;
+ var finalOffset = 0;
+ var pixelOffset = 0;
+ var outputBuffer = this.heightBuffer;
+ while (pixelOffset < this.finalResultSize) {
+ //Calculate weightings:
+ secondWeight = weight % 1;
+ firstWeight = 1 - secondWeight;
+ //Interpolate:
+ for (pixelOffset = Math.floor(weight) * 4; pixelOffset < this.targetWidthMultipliedByChannels; pixelOffset += 4) {
+ outputBuffer[finalOffset++] = (buffer[pixelOffset] * firstWeight) + (buffer[pixelOffset + 4] * secondWeight);
+ outputBuffer[finalOffset++] = (buffer[pixelOffset + 1] * firstWeight) + (buffer[pixelOffset + 5] * secondWeight);
+ outputBuffer[finalOffset++] = (buffer[pixelOffset + 2] * firstWeight) + (buffer[pixelOffset + 6] * secondWeight);
+ outputBuffer[finalOffset++] = (buffer[pixelOffset + 3] * firstWeight) + (buffer[pixelOffset + 7] * secondWeight);
+ }
+ weight += ratioWeight;
+ }
+ return outputBuffer;
+}
+Resize.prototype.resize = function (buffer) {
+ return this.resizeHeight(this.resizeWidth(buffer));
+}
+Resize.prototype.bypassResizer = function (buffer) {
+ //Just return the buffer passsed:
+ return buffer;
+}
+Resize.prototype.initializeFirstPassBuffers = function (BILINEARAlgo) {
+ //Initialize the internal width pass buffers:
+ this.widthBuffer = this.generateFloatBuffer(this.widthPassResultSize);
+ if (!BILINEARAlgo) {
+ this.outputWidthWorkBench = this.generateFloatBuffer(this.originalHeightMultipliedByChannels);
+ }
+}
+Resize.prototype.initializeSecondPassBuffers = function (BILINEARAlgo) {
+ //Initialize the internal height pass buffers:
+ this.heightBuffer = this.generateUint8Buffer(this.finalResultSize);
+ if (!BILINEARAlgo) {
+ this.outputHeightWorkBench = this.generateFloatBuffer(this.targetWidthMultipliedByChannels);
+ }
+}
+Resize.prototype.generateFloatBuffer = function (bufferLength) {
+ //Generate a float32 typed array buffer:
+ try {
+ return new Float32Array(bufferLength);
+ }
+ catch (error) {
+ return [];
+ }
+}
+Resize.prototype.generateUint8Buffer = function (bufferLength) {
+ //Generate a uint8 typed array buffer:
+ try {
+ return this.checkForOperaMathBug(new Uint8Array(bufferLength));
+ }
+ catch (error) {
+ return [];
+ }
+}
+Resize.prototype.checkForOperaMathBug = function (typedArray) {
+ typedArray[0] = -1;
+ typedArray[0] >>= 0;
+ if (typedArray[0] != 0xFF) {
+ return [];
+ }
+ else {
+ return typedArray;
+ }
+}
+
+// End of js/other/resize.js file.
+
+// Remaining files are in gbemu-part2.js, since they run in strict mode.
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-28 10:13:59 +0000