/**  The Emularity; easily embed emulators
  *  Copyright © 2014-2016 Daniel Brooks <db48x@db48x.net>, Jason
  *  Scott <jscott@archive.org>, Grant Galitz <grantgalitz@gmail.com>,
  *  John Vilk <jvilk@cs.umass.edu>, and Tracey Jaquith <tracey@archive.org>
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  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.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */

var Module = null;

(function (Promise) {
   /**
    * IALoader
    */
   function IALoader(canvas, game, callbacks, scale) {
     // IA actually gives us an object here, and we really ought to be
     // looking things up from it instead.
     if (typeof game !== 'string') {
       game = game.toString();
     }
     if (!callbacks || typeof callbacks !== 'object') {
       callbacks = { before_emulator: updateLogo,
                     before_run: callbacks };
     } else {
       if (typeof callbacks.before_emulator === 'function') {
         var func = callbacks.before_emulator;
         callbacks.before_emulator = function () {
                                       updateLogo();
                                       func();
                                     };
       } else {
         callbacks.before_emulator = updateLogo;
       }
     }

     function img(src) {
       var img = new Image();
       img.src = src;
       return img;
     }

     // yea, this is a hack
     var images;
     if (/archive\.org$/.test(document.location.hostname)) {
       images = { ia: img("/images/ialogo.png"),
                  mame: img("/images/mame.png"),
                  mess: img("/images/mame.png"),
                  dosbox: img("/images/dosbox.png"),
                  sae: img("/images/sae.png"),
                  pce: img("/images/pce.png")
                };
     } else {
       images = { ia: img("other_logos/ia-logo-150x150.png"),
                  mame: img("other_logos/mame.png"),
                  mess: img("other_logos/mame.png"),
                  dosbox: img("other_logos/dosbox.png"),
                  sae: img("other_logos/sae.png"),
                  pce: img("other_logos/pce.png")
                };
     }

     function updateLogo() {
      /*
       if (emulator_logo) {
         emulator.setSplashImage(emulator_logo);
       }
       */
     }

     var SAMPLE_RATE = (function () {
                          var audio_ctx = window.AudioContext || window.webkitAudioContext || false;
                          if (!audio_ctx) {
                            return false;
                          }
                          var sample = new audio_ctx;
                          return sample.sampleRate.toString();
                        }());

     var metadata, filelist, module, modulecfg, config_args, emulator_logo,
         emulator = new Emulator(canvas).setScale(scale)
                                        //.setSplashImage(images.ia) // BORA
                                        .setLoad(loadFiles)
                                        .setCallbacks(callbacks);

     var cfgr;
     function loadFiles(fetch_file, splash) {
       splash.setTitle("Downloading metadata...");
       return new Promise(function (resolve, reject) {
                            var loading = fetch_file('Metadata',
                                                     get_meta_url(game),
                                                     'document');
                            loading.then(function (data) {
                                           metadata = data;
                                           splash.setTitle("Downloading file list...");
                                           return fetch_file('File List',
                                                             get_files_url(game),
                                                             'document', true);
                                         },
                                         function () {
                                           splash.setTitle("Failed to download IA item metadata!");
                                           splash.failed_loading = true;
                                           reject(1);
                                         })
                                   .then(function (data) {
                                           if (splash.failed_loading) {
                                             return null;
                                           }
                                           filelist = data;
                                           splash.setTitle("Downloading emulator metadata...");
                                           module = metadata.getElementsByTagName("emulator")
                                                            .item(0)
                                                            .textContent;
                                           return fetch_file('Emulator Metadata',
                                                             get_emulator_config_url(module),
                                                             'text', true);
                                         },
                                         function () {
                                           if (splash.failed_loading) {
                                             return;
                                           }
                                           splash.setTitle("Failed to download file list!");
                                           splash.failed_loading = true;
                                           reject(2);
                                         })
                                   .then(function (data) {
                                           if (splash.failed_loading) {
                                             return null;
                                           }

                                           modulecfg = JSON.parse(data);
                                           var get_files;

                                           if (module && module.indexOf("dosbox") === 0) {
                                             emulator_logo = images.dosbox;
                                             cfgr = DosBoxLoader;
                                             get_files = get_dosbox_files;
                                           }
                                           else if (module && module.indexOf("sae-") === 0) {
                                             emulator_logo = images.sae;
                                             cfgr = SAELoader;
                                             get_files = get_sae_files;
                                           }
                                           else if (module && module.indexOf("pce-") === 0) {
                                             emulator_logo = images.pce;
                                             cfgr = PCELoader;
                                             get_files = get_pce_files;
                                           }
                                           else if (module) {
                                             emulator_logo = images.mame;
                                             cfgr = MAMELoader;
                                             get_files = get_mame_files;
                                           }
                                           else {
                                             throw new Error("Unknown module type "+ module +"; cannot configure the emulator.");
                                           }

                                           var wantsWASM = modulecfg.wasm_filename && 'WebAssembly' in window;
                                           var nr = modulecfg['native_resolution'];
                                           config_args = [cfgr.emulatorJS(get_js_url(wantsWASM ? modulecfg.wasmjs_filename : modulecfg.js_filename)),
                                                          cfgr.emulatorWASM(wantsWASM && get_js_url(modulecfg.wasm_filename)),
                                                          cfgr.locateAdditionalEmulatorJS(locateAdditionalJS),
                                                          cfgr.fileSystemKey(game),
                                                          cfgr.nativeResolution(nr[0], nr[1]),
                                                          cfgr.aspectRatio(nr[0] / nr[1]),
                                                          cfgr.sampleRate(SAMPLE_RATE)];

                                           if ('keepAspect' in cfgr) {
                                             cfgr.keepAspect(modulecfg.keepAspect);
                                           }

                                           if (/archive\.org$/.test(document.location.hostname)) {
                                             cfgr.muted(!(typeof $ !== 'undefined' && $.cookie && $.cookie('unmute')));
                                           }

                                           if (module && module.indexOf("dosbox") === 0) {
                                             config_args.push(cfgr.startExe(metadata.getElementsByTagName("emulator_start")
                                                                                    .item(0)
                                                                                    .textContent));
                                           } else if (module && module.indexOf("sae-") === 0) {
                                             config_args.push(cfgr.model(modulecfg.driver),
                                                              cfgr.rom(modulecfg.bios_filenames));
                                           } else if (module && module.indexOf("pce-") === 0) {
                                             config_args.push(cfgr.model(modulecfg.driver));
                                           } else if (module) { // MAME
                                             config_args.push(cfgr.driver(modulecfg.driver),
                                                              cfgr.extraArgs(modulecfg.extra_args));
                                           }

                                           splash.setTitle("Downloading data...");
                                           return Promise.all(get_files(cfgr, metadata, modulecfg, filelist));
                                         },
                                         function () {
                                           if (splash.failed_loading) {
                                             return;
                                           }
                                           splash.setTitle("Failed to download emulator metadata!");
                                           splash.failed_loading = true;
                                           reject(2);
                                         })
                                   .then(function (game_files) {
                                           if (splash.failed_loading) {
                                             return;
                                           }
                                           updateLogo();
                                           resolve(cfgr.apply(null, extend(config_args, game_files)));
                                         },
                                         function () {
                                           if (splash.failed_loading) {
                                             return;
                                           }
                                           splash.setTitle("Failed to configure emulator!");
                                           splash.failed_loading = true;
                                           reject(3);
                                         });
                          });
     }

     function locateAdditionalJS(filename) {
       if ("file_locations" in modulecfg && filename in modulecfg.file_locations) {
         return get_js_url(modulecfg.file_locations[filename]);
       }
       return get_js_url(filename);
     }

     function get_dosbox_files(cfgr, metadata, modulecfg, filelist) {
       var default_drive = "c", // pick any drive letter as a default
           drives = {}, files = [],
           meta = dict_from_xml(metadata);
       if (game && game.endsWith(".zip")) {
         drives[default_drive] = game;
       }
       files_with_ext_from_filelist(filelist, meta.emulator_ext).forEach(function (file, i) {
                                                                           drives[default_drive] = file.name;
                                                                         });
       meta_props_matching(meta, /^dosbox_drive_([a-zA-Z])$/).forEach(function (result) {
                                                                        let key = result[0], match = result[1];
                                                                        drives[match[1]] = meta[key];
                                                                      });
       var mounts = Object.keys(drives),
           len = mounts.length;
       mounts.forEach(function (drive, i) {
                        var title = "Hard Disk ("+ (i+1) +" of "+ len +")",
                            filename = drives[drive],
                            url = (filename.includes("/")) ? get_zip_url(filename)
                                                           : get_zip_url(filename, get_item_name(game));
                            if (filename.toLowerCase().endsWith(".zip")) {
                              files.push(cfgr.mountZip(drive,
                                                       cfgr.fetchFile(title, url)));
                            } else {
                              files.push(cfgr.mountFile('/'+ filename,
                                                        cfgr.fetchFile(title, url)));
                            }
                      });
       return files;
     }

     function get_mame_files(cfgr, metadata, modulecfg, filelist) {
       var files = [],
           bios_files = modulecfg['bios_filenames'];
       bios_files.forEach(function (fname, i) {
                            if (fname) {
                              var title = "Bios File ("+ (i+1) +" of "+ bios_files.length +")";
                              files.push(cfgr.mountFile('/'+ fname,
                                                        cfgr.fetchFile(title,
                                                                       get_bios_url(fname))));
                            }
                          });

       var meta = dict_from_xml(metadata),
           peripherals = {},
           game_files_counter = {};
       files_with_ext_from_filelist(filelist, meta.emulator_ext).forEach(function (file, i) {
                                                                           game_files_counter[file.name] = 1;
                                                                           if (modulecfg.peripherals && modulecfg.peripherals[i]) {
                                                                             peripherals[modulecfg.peripherals[i]] = file.name;
                                                                           }
                                                                         });
       meta_props_matching(meta, /^mame_peripheral_([a-zA-Z0-9]+)$/).forEach(function (result) {
                                                                               let key = result[0], match = result[1];
                                                                               peripherals[match[1]] = meta[key];
                                                                               game_files_counter[meta[key]] = 1;
                                                                             });

       var game_files = Object.keys(game_files_counter),
           len = game_files.length;
       game_files.forEach(function (filename, i) {
                            var title = "Hard Disk ("+ (i+1) +" of "+ len +")",
                                url = (filename.includes("/")) ? get_zip_url(filename)
                                                               : get_zip_url(filename, get_item_name(game));
                            files.push(cfgr.mountFile('/'+ filename,
                                                      cfgr.fetchFile(title, url)));
                          });
       Object.keys(peripherals).forEach(function (periph) {
                                          files.push(cfgr.peripheral(periph,                // we're not pushing a 'file' here,
                                                                     peripherals[periph])); // but that's ok
                                        });

       files.push(cfgr.mountFile('/'+ modulecfg['driver'] + '.cfg',
                                 cfgr.fetchOptionalFile("CFG File",
                                                        get_other_emulator_config_url(module))));
       return files;
     }

     function get_sae_files(cfgr, metadata, modulecfg, filelist) {
       var files = [],
           bios_files = modulecfg['bios_filenames'];
       bios_files.forEach(function (fname, i) {
                            if (fname) {
                              var title = "Bios File ("+ (i+1) +" of "+ bios_files.length +")";
                              files.push(cfgr.mountFile('/'+ fname,
                                                        cfgr.fetchFile(title,
                                                                       get_bios_url(fname))));
                            }
                          });

       var meta = dict_from_xml(metadata),
           game_files = files_with_ext_from_filelist(filelist, meta.emulator_ext);
       game_files.forEach(function (file, i) {
                            if (file) {
                              var title = "Hard Disk ("+ (i+1) +" of "+ game_files.length +")",
                                  url = (file.name.includes("/")) ? get_zip_url(file.name)
                                                                  : get_zip_url(file.name, get_item_name(game));
                              files.push(cfgr.mountFile('/'+ file.name,
                                                        cfgr.fetchFile(title, url)));
                              files.push(cfgr.floppy(0,             // we're not pushing a file here
                                                     file.name));   // but that's ok
                            }
                          });
       files.push(cfgr.mountFile('/'+ modulecfg['driver'] + '.cfg',
                                 cfgr.fetchOptionalFile("Config File",
                                                        get_other_emulator_config_url(module))));
       return files;
     }

     function get_pce_files(cfgr, metadata, modulecfg, filelist) {
       var files = [],
           bios_files = modulecfg['bios_filenames'];
       bios_files.forEach(function (fname, i) {
                            if (fname) {
                              var title = "ROM File ("+ (i+1) +" of "+ bios_files.length +")";
                              files.push(cfgr.mountFile('/'+ fname,
                                                        cfgr.fetchFile(title,
                                                                       get_bios_url(fname))));
                            }
                          });

       var meta = dict_from_xml(metadata),
           game_files_counter = {};
       files_with_ext_from_filelist(filelist, meta.emulator_ext).forEach(function (file, i) {
                                                                           if (modulecfg.peripherals && modulecfg.peripherals[i]) {
                                                                             game_files_counter[file.name] = modulecfg.peripherals[i];
                                                                           }
                                                                         });
       meta_props_matching(meta, /^pce_drive_([a-zA-Z0-9]+)$/).forEach(function (result) {
                                                                         var key = result[0], periph = result[1][1];
                                                                         game_files_counter[meta[key]] = periph;
                                                                       });

       var game_files = Object.keys(game_files_counter),
           len = game_files.length;
       game_files.forEach(function (filename, i) {
                            var title = "Hard Disk ("+ (i+1) +" of "+ len +")",
                                ext = filename.match(/\.([^.]*)$/)[1],
                                url = (filename.includes("/")) ? get_zip_url(filename)
                                                               : get_zip_url(filename, get_item_name(game));
                            files.push(cfgr.mountFile('/'+ game_files_counter[filename] +'.'+ ext,
                                                      cfgr.fetchFile(title, url)));
                          });

       files.push(cfgr.mountFile('/pce-'+ modulecfg['driver'] + '.cfg',
                                 cfgr.fetchOptionalFile("Config File",
                                                        get_other_emulator_config_url("pce-"+ modulecfg['driver']))));
       return files;
     }
     var get_item_name = function (game_path) {
       return game_path.split('/').shift();
     };

     var get_game_name = function (game_path) {
       return game_path.split('/').pop();
     };

     // NOTE: deliberately use cors.archive.org since this will 302 rewrite to iaXXXXX.us.archive.org/XX/items/...
     // and need to keep that "artificial" extra domain-ish name to avoid CORS issues with IE/Safari  (tracey@archive)
     var get_emulator_config_url = function (module) {
       return 'emularity_engine_v1/' + module + '.json';
     };

     var get_other_emulator_config_url = function (module) {
       return 'emularity_config_v1/' + module + '.cfg';
     };

     var get_meta_url = function (game_path) {
       var path = game_path.split('/');
       return "meta.xml";
     };

     var get_files_url = function (game_path) {
       var path = game_path.split('/');
       return "files.xml";
     };

     var get_zip_url = function (game_path, item_path) {
       if (item_path) {
         return item_path +"/"+ game_path;
       }
       return game_path;
     };

     var get_js_url = function (js_filename) {
       console.log(">>>>", js_filename);
       if (js_filename.endsWith(".gz")) {
         console.log("OKKK", "emularity_engine_v1/"+ js_filename.slice(0, -3));
         return "emularity_engine_v1/"+ js_filename.slice(0, -3);
       }
       return "emularity_engine_v1/"+ js_filename;
     };

     var get_bios_url = function (bios_filename) {
       return "emularity_bios_v1/"+ bios_filename;
     };

     function mountat (drive) {
       return function (data) {
         return { drive: drive,
                  mountpoint: "/" + drive,
                  data: data
                };
       };
     }

     return emulator;
   }

   /**
    * BaseLoader
    */
   function BaseLoader() {
     return Array.prototype.reduce.call(arguments, extend);
   }

   BaseLoader.canvas = function (id) {
     var elem = id instanceof Element ? id : document.getElementById(id);
     return { canvas: elem };
   };

   BaseLoader.emulatorJS = function (url) {
     return { emulatorJS: url };
   };

   BaseLoader.emulatorWASM = function (url) {
     return { emulatorWASM: url };
   };

   BaseLoader.locateAdditionalEmulatorJS = function (func) {
     return { locateAdditionalJS: func };
   };

   BaseLoader.fileSystemKey = function (key) {
     return { fileSystemKey: key };
   };

   BaseLoader.nativeResolution = function (width, height) {
     if (typeof width !== 'number' || typeof height !== 'number')
       throw new Error("Width and height must be numbers");
     return { nativeResolution: { width: Math.floor(width), height: Math.floor(height) } };
   };

   BaseLoader.aspectRatio = function (ratio) {
     if (typeof ratio !== 'number')
       throw new Error("Aspect ratio must be a number");
     return { aspectRatio: ratio };
   };

   BaseLoader.sampleRate = function (rate) {
     return { sample_rate: rate };
   };

   BaseLoader.muted = function (muted) {
     return { muted: muted };
   };

   BaseLoader.mountZip = function (drive, file) {
     return { files: [{ drive: drive,
                        mountpoint: "/" + drive,
                        file: file
                      }] };
   };

   BaseLoader.mountFile = function (filename, file) {
     return { files: [{ mountpoint: filename,
                        file: file
                      }] };
   };

   BaseLoader.fetchFile = function (title, url) {
     return { title: title, url: url, optional: false };
   };

   BaseLoader.fetchOptionalFile = function (title, url) {
     return { title: title, url: url, optional: true };
   };

   BaseLoader.localFile = function (title, data) {
     return { title: title, data: data };
   };

   /**
    * DosBoxLoader
    */
   function DosBoxLoader() {
     var config = Array.prototype.reduce.call(arguments, extend);
     config.emulator_arguments = build_dosbox_arguments(config.emulatorStart, config.files, config.extra_dosbox_args);
     config.runner = EmscriptenRunner;
     return config;
   }
   DosBoxLoader.__proto__ = BaseLoader;

   DosBoxLoader.startExe = function (path) {
     return { emulatorStart: path };
   };

   DosBoxLoader.extraArgs = function (args) {
     return { extra_dosbox_args: args };
   };

   /**
    * MAMELoader
    */
   function MAMELoader() {
     var config = Array.prototype.reduce.call(arguments, extend);
     config.emulator_arguments = build_mame_arguments(config.muted, config.mame_driver,
                                                      config.nativeResolution, config.sample_rate,
                                                      config.peripheral, config.extra_mame_args,
                                                      config.keep_aspect);
     config.runner = MAMERunner;
     return config;
   }
   MAMELoader.__proto__ = BaseLoader;

   MAMELoader.driver = function (driver) {
     return { mame_driver: driver };
   };

   MAMELoader.peripheral = function (peripheral, game) {
     var p = {};
     p[peripheral] = [game];
     return { peripheral: p };
   };

   MAMELoader.keepAspect = function (keep) {
     return { keep_aspect: !!keep };
   };

   MAMELoader.extraArgs = function (args) {
     return { extra_mame_args: args };
   };

   /**
    * SAELoader
    */

   function SAELoader() {
     var config = Array.prototype.reduce.call(arguments, extend);
     config.runner = SAERunner;
     return config;
   }
   SAELoader.__proto__ = BaseLoader;

   SAELoader.model = function (model) {
     return { amigaModel: model };
   };

   SAELoader.fastMemory = function (megabytes) {
     return { fast_memory: megabytes << 20 };
   };

   SAELoader.rom = function (filenames) {
     if (typeof filenames == "string")
       filenames = [filenames];
     return { rom: filenames[0], extRom: filenames[1] };
   };

   SAELoader.floppy = function (index, filename) {
     var f = {};
     f[index] = filename;
     return { floppy: f };
   };

   SAELoader.ntsc = function (v) {
     return { ntsc: !!v };
   };

   /**
    * PCELoader
    */

   function PCELoader() {
     var config = Array.prototype.reduce.call(arguments, extend);
     config.emulator_arguments = ["-c", "/emulator/pce-"+ config.pceModel +".cfg"];
     config.runner = EmscriptenRunner;
     return config;
   }
   PCELoader.__proto__ = BaseLoader;

   PCELoader.model = function (model) {
     return { pceModel: model };
   };

   var build_mame_arguments = function (muted, driver, native_resolution, sample_rate, peripheral, extra_args, keepaspect) {
     var args = [driver,
                 '-verbose',
                 '-rompath', 'emulator',
                 '-window',
                 keepaspect ? '-keepaspect' : '-nokeepaspect'];

     if (native_resolution && "width" in native_resolution && "height" in native_resolution) {
       args.push('-resolution', [native_resolution.width, native_resolution.height].join('x'));
     }

     if (muted) {
       args.push('-sound', 'none');
     } else if (sample_rate) {
       args.push('-samplerate', sample_rate);
     }

     if (peripheral) {
       for (var p in peripheral) {
         if (Object.prototype.propertyIsEnumerable.call(peripheral, p)) {
           args.push('-' + p,
                     '/emulator/'+ (peripheral[p][0].replace(/\//g,'_')));
         }
       }
     }

     if (extra_args) {
       args = args.concat(extra_args);
     }

     return args;
   };

   var build_dosbox_arguments = function (emulator_start, files, extra_args) {
     var args = ['-conf', '/emulator/dosbox.conf'];

     var len = files.length;
     for (var i = 0; i < len; i++) {
       if ('drive' in files[i]) {
         args.push('-c', 'mount '+ files[i].drive +' /emulator'+ files[i].mountpoint);
       }
     }

     if (extra_args) {
       args = args.concat(extra_args);
     }

     var path = emulator_start.split(/\\|\//); // I have LTS already
     args.push('-c', /^[a-zA-Z]:$/.test(path[0]) ? path.shift() : 'c:');
     var prog = path.pop();
     if (path && path.length)
       args.push('-c', 'cd '+ path.join('/'));
     args.push('-c', prog);

     return args;
   };

   /*
    * EmscriptenRunner
    */
   function EmscriptenRunner(canvas, game_data) {
     var self = this;
     this._hooks = { start: [], reset: [] };
     // This is somewhat wrong, because our Emscripten-based emulators
     // are currently compiled to start immediately when their js file
     // is loaded.
     Module = { arguments: game_data.emulator_arguments,
                screenIsReadOnly: true,
                print: function (text) { console.log(text); },
                printErr: function (text) { console.log(text); },
                canvas: canvas,
                noInitialRun: false,
                locateFile: game_data.locateAdditionalJS,
                wasmBinary: game_data.wasmBinary,
                preInit: function () {
                           // Re-initialize BFS to just use the writable in-memory storage.
                           BrowserFS.initialize(game_data.fs);
                           var BFS = new BrowserFS.EmscriptenFS();
                           // Mount the file system into Emscripten.
                           FS.mkdir('/emulator');
                           FS.mount(BFS, {root: '/'}, '/emulator');
                         },
                preRun: [function () {
                            self._hooks.start.forEach(function (f) {
                                                        //try {
                                                          f && f();
                                                        //} catch(x) {
                                                        //  console.warn(x);
                                                        //}
                                                      });
                          }]
              };
   }

   EmscriptenRunner.prototype.start = function () {
   };

   EmscriptenRunner.prototype.pause = function () {
   };

   EmscriptenRunner.prototype.stop = function () {
   };

   EmscriptenRunner.prototype.mute = function () {
     try {
       if (!SDL_PauseAudio)
         SDL_PauseAudio = Module.cwrap('SDL_PauseAudio', '', ['number']);
       SDL_PauseAudio(true);
     } catch (x) {
       console.log("Unable to change audio state:", x);
     }
   };

   EmscriptenRunner.prototype.unmute = function () {
     try {
       if (!SDL_PauseAudio)
         SDL_PauseAudio = Module.cwrap('SDL_PauseAudio', '', ['number']);
       SDL_PauseAudio(false);
     } catch (x) {
       console.log("Unable to change audio state:", x);
     }
   };

   EmscriptenRunner.prototype.onStarted = function (func) {
     this._hooks.start.push(func);
   };

   EmscriptenRunner.prototype.onReset = function (func) {
     this._hooks.reset.push(func);
   };

   EmscriptenRunner.prototype.requestFullScreen = function () {
   };

   /*
    * MAMERunner
    */
   function MAMERunner() {
     return EmscriptenRunner.apply(this, arguments);
   }
   MAMERunner.prototype = Object.create(EmscriptenRunner.prototype,
                                        {
                                          mute: function () {
                                                  var soundmgr = Module.__ZN15running_machine20emscripten_get_soundEv(Module.__ZN15running_machine30emscripten_get_running_machineEv());
                                                  Module.__ZN13sound_manager4muteEbh(soundmgr,
                                                                                     true,
                                                                                     0x02); // MUTE_REASON_UI
                                                },
                                          unmute: function () {
                                                    var soundmgr = Module.__ZN15running_machine20emscripten_get_soundEv(Module.__ZN15running_machine30emscripten_get_running_machineEv());
                                                    Module.__ZN13sound_manager4muteEbh(soundmgr,
                                                                                       false,
                                                                                       0x02); // MUTE_REASON_UI
                                                  }
                                        });

   /*
    * SAERunner
    */
   function SAERunner(canvas, game_data) {
     this._sae = new ScriptedAmigaEmulator();
     this._cfg = this._sae.getConfig();
     this._canvas = canvas;

     var model = null;
     switch (game_data.amigaModel) {
       case "A500": model = SAEC_Model_A500; break;
       case "A500P": model = SAEC_Model_A500P; break;
       case "A600": model = SAEC_Model_A600; break;
       case "A1000": model = SAEC_Model_A1000; break;
       case "A1200": model = SAEC_Model_A1200; break;
       case "A2000": model = SAEC_Model_A2000; break;
       case "A3000": model = SAEC_Model_A3000; break;
       case "A4000": model = SAEC_Model_A4000; break;
       case "A4000T": model = SAEC_Model_A4000T; break;
       /*  future. do not use. cd-emulation is not implemented yet.
       case "CDTV": model = SAEC_Model_CDTV; break;
       case "CD32": model = SAEC_Model_CD32; break; */
     }
     this._sae.setModel(model, 0);
     this._cfg.memory.z2FastSize = game_data.fastMemory || 2 << 20;
     this._cfg.floppy.speed = SAEC_Config_Floppy_Speed_Turbo;
     this._cfg.video.id = canvas.getAttribute("id");

     if (game_data.nativeResolution && game_data.nativeResolution.height == 360 && game_data.nativeResolution.width == 284)
     {
       this._cfg.video.hresolution = SAEC_Config_Video_HResolution_LoRes;
       this._cfg.video.vresolution = SAEC_Config_Video_VResolution_NonDouble;
       this._cfg.video.size_win.width = SAEC_Video_DEF_AMIGA_WIDTH; /* 360 */
       this._cfg.video.size_win.height = SAEC_Video_DEF_AMIGA_HEIGHT; /* 284 */
     }
     else if (game_data.nativeResolution && game_data.nativeResolution.height == 1440 && game_data.nativeResolution.width == 568)
     {
       this._cfg.video.hresolution = SAEC_Config_Video_HResolution_SuperHiRes;
       this._cfg.video.vresolution = SAEC_Config_Video_VResolution_Double;
       this._cfg.video.size_win.width = SAEC_Video_DEF_AMIGA_WIDTH << 2; /* 1440 */
       this._cfg.video.size_win.height = SAEC_Video_DEF_AMIGA_HEIGHT << 1; /* 568 */
     }
     else
     {
       this._cfg.video.hresolution = SAEC_Config_Video_HResolution_HiRes;
       this._cfg.video.vresolution = SAEC_Config_Video_VResolution_Double;
       this._cfg.video.size_win.width = SAEC_Video_DEF_AMIGA_WIDTH << 1; /* 720 */
       this._cfg.video.size_win.height = SAEC_Video_DEF_AMIGA_HEIGHT << 1; /* 568 */
     }

     this._cfg.memory.rom.name = game_data.rom;
     this._cfg.memory.rom.data = game_data.fs.readFileSync('/'+game_data.rom, null, flag_r);
     this._cfg.memory.rom.size = this._cfg.memory.rom.data.length;

     if (game_data.extRom) {
       this._cfg.memory.extRom.name = game_data.extRom;
       this._cfg.memory.extRom.data = game_data.fs.readFileSync('/'+game_data.extRom, null, flag_r);
       this._cfg.memory.extRom.size = this._cfg.memory.extRom.data.length;
     }

     this._cfg.floppy.drive[0].file.name = game_data.floppy[0];
     this._cfg.floppy.drive[0].file.data = game_data.fs.readFileSync('/'+game_data.floppy[0], null, flag_r);
     this._cfg.floppy.drive[0].file.size = this._cfg.floppy.drive[0].file.data.length;
   }

   SAERunner.prototype.start = function () {
     var err = this._sae.start();
   };

   SAERunner.prototype.pause = function () {
     this._sae.pause();
   };

   SAERunner.prototype.stop = function () {
     this._sae.stop();
   };

   SAERunner.prototype.mute = function () {
     var err = this._sae.mute(true);
     if (err) {
       console.warn("unable to mute; SAE error number", err);
     }
   };

   SAERunner.prototype.unmute = function () {
     var err = this._sae.mute(false);
     if (err) {
       console.warn("unable to unmute; SAE error number", err);
     }
   };

   SAERunner.prototype.onStarted = function (func) {
     this._cfg.hook.event.started = func;
   };

   SAERunner.prototype.onReset = function (func) {
     this._cfg.hook.event.reseted = func;
   };

   SAERunner.prototype.requestFullScreen = function () {
     getfullscreenenabler().call(this._canvas);
   };

   /**
    * Emulator
    */
   function Emulator(canvas, callbacks, loadFiles) {
     if (typeof callbacks !== 'object') {
       callbacks = { before_emulator: null,
                     before_run: callbacks };
     }
     var js_url;
     var requests = [];
     var drawloadingtimer;
     // TODO: Have an enum value that communicates the current state of the emulator, e.g. 'initializing', 'loading', 'running'.
     var has_started = false;
     var loading = false;
     var defaultSplashColors = { foreground: 'white',
                                 background: 'black',
                                 failure: 'red' };
     var splash = { loading_text: "",
                    spinning: true,
                    finished_loading: false,
                    colors: defaultSplashColors,
                    table: null,
                    splashimg: new Image() };

     var runner;

     var muted = false;
     var SDL_PauseAudio;
     this.isMuted = function () { return muted; };
     this.mute = function () { return this.setMute(true); };
     this.unmute = function () { return this.setMute(false); };
     this.toggleMute = function () { return this.setMute(!muted); };
     this.setMute = function (state) {
       muted = state;
       if (runner) {
         if (state) {
           runner.mute();
         } else {
           runner.unmute();
         }
       }
       else {
         try {
           if (!SDL_PauseAudio)
             SDL_PauseAudio = Module.cwrap('SDL_PauseAudio', '', ['number']);
           SDL_PauseAudio(state);
         } catch (x) {
           console.log("Unable to change audio state:", x);
         }
       }
       return this;
     };

     // This is the bare minimum that will allow gamepads to work. If
     // we don't listen for them then the browser won't tell us about
     // them.
     // TODO: add hooks so that some kind of UI can be displayed.
     window.addEventListener("gamepadconnected",
                             function (e) {
                               console.log("Gamepad connected at index %d: %s. %d buttons, %d axes.",
                                           e.gamepad.index, e.gamepad.id,
                                           e.gamepad.buttons.length, e.gamepad.axes.length);
                             });

     window.addEventListener("gamepaddisconnected",
                             function (e) {
                               console.log("Gamepad disconnected from index %d: %s",
                                           e.gamepad.index, e.gamepad.id);
                             });

     if (/archive\.org$/.test(document.location.hostname) && document.getElementById("gofullscreen")) {
       document.getElementById("gofullscreen").addEventListener("click", this.requestFullScreen);
     }

     var css_resolution, scale, aspectRatio;
     // right off the bat we set the canvas's inner dimensions to
     // whatever it's current css dimensions are; this isn't likely to be
     // the same size that dosbox/jsmame will set it to, but it avoids
     // the case where the size was left at the default 300x150
     if (!canvas.hasAttribute("width")) {
       var style = getComputedStyle(canvas);
       canvas.width = parseInt(style.width, 10);
       canvas.height = parseInt(style.height, 10);
     }

     this.setScale = function(_scale) {
       scale = _scale;
       return this;
     };

     this.setSplashImage = function(_splashimg) {
       if (_splashimg) {
         if (_splashimg instanceof Image) {
           if (splash.splashimg.parentNode) {
             splash.splashimg.src = _splashimg.src;
           } else {
             splash.splashimg = _splashimg;
           }
         } else {
           splash.splashimg.src = _splashimg;
         }
       }
       return this;
     };

     this.setCSSResolution = function(_resolution) {
       css_resolution = _resolution;
       return this;
     };

     this.setAspectRatio = function(_aspectRatio) {
       aspectRatio = _aspectRatio;
       return this;
     };

     this.setCallbacks = function(_callbacks) {
       if (typeof _callbacks !== 'object') {
         callbacks = { before_emulator: null,
                       before_run: _callbacks };
       } else {
         callbacks = _callbacks;
       }
       return this;
     };

     this.setSplashColors = function (colors) {
       splash.colors = colors;
       return this;
     };

     this.setLoad = function (loadFunc) {
       loadFiles = loadFunc;
       return this;
     };

     var start = function (options) {
       if (has_started)
         return false;
       has_started = true;
       var defaultOptions = { waitAfterDownloading: false,
                              hasCustomCSS: false };
       if (typeof options !== 'object') {
         options = defaultOptions;
       } else {
         options.__proto__ = defaultOptions;
       }

       var k, c, game_data;
       setupSplash(canvas, splash, options);
       drawsplash();

       var loading;

       if (typeof loadFiles === 'function') {
         loading = loadFiles(fetch_file, splash);
       } else {
         loading = Promise.resolve(loadFiles);
       }
       loading.then(function (_game_data) {
                      return new Promise(function(resolve, reject) {
                        var inMemoryFS = new BrowserFS.FileSystem.InMemory();
                        // If the browser supports IndexedDB storage, mirror writes to that storage
                        // for persistence purposes.
                        if (BrowserFS.FileSystem.IndexedDB.isAvailable()) {
                          var AsyncMirrorFS = BrowserFS.FileSystem.AsyncMirror,
                              IndexedDB = BrowserFS.FileSystem.IndexedDB;
                          deltaFS = new AsyncMirrorFS(inMemoryFS,
                                                      new IndexedDB(function(e, fs) {
                                                                      if (e) {
                                                                        // we probably weren't given access;
                                                                        // private window for example.
                                                                        // don't fail completely, just don't
                                                                        // use indexeddb
                                                                        deltaFS = inMemoryFS;
                                                                        finish();
                                                                      } else {
                                                                        // Initialize deltaFS by copying files from async storage to sync storage.
                                                                        deltaFS.initialize(function (e) {
                                                                                             if (e) {
                                                                                               reject(e);
                                                                                             } else {
                                                                                               finish();
                                                                                             }
                                                                                           });
                                                                      }
                                                                    },
                                                                    "fileSystemKey" in _game_data ? _game_data.fileSystemKey
                                                                                                  : "emularity"));
                        } else {
                          finish();
                        }

                        function finish() {
                          game_data = _game_data;

                          // Any file system writes to MountableFileSystem will be written to the
                          // deltaFS, letting us mount read-only zip files into the MountableFileSystem
                          // while being able to "write" to them.
                          game_data.fs = new BrowserFS.FileSystem.OverlayFS(deltaFS,
                                                                            new BrowserFS.FileSystem.MountableFileSystem());
                          game_data.fs.initialize(function (e) {
                            if (e) {
                              console.error("Failed to initialize the OverlayFS:", e);
                              reject();
                            } else {
                              var Buffer = BrowserFS.BFSRequire('buffer').Buffer;
                              function fetch(file) {
                                if ('data' in file && file.data !== null && typeof file.data !== 'undefined') {
                                  return Promise.resolve(file.data);
                                }
                                return fetch_file(file.title, file.url, 'arraybuffer', file.optional);
                              }
                              function mountat(drive) {
                                return function (data) {
                                  if (data !== null) {
                                    drive = drive.toLowerCase();
                                    var mountpoint = '/'+ drive;
                                    // Mount into RO MFS.
                                    game_data.fs.getOverlayedFileSystems().readable.mount(mountpoint, BFSOpenZip(new Buffer(data)));
                                  }
                                };
                              }
                              function saveat(filename) {
                                return function (data) {
                                  if (data !== null) {
                                    if (filename.includes('/')) {
                                      var parts = filename.split('/');
                                      for (var i = 1; i < parts.length; i++) {
                                        var path = '/'+ parts.slice(0, i).join('/');
                                        if (!game_data.fs.existsSync(path)) {
                                          game_data.fs.mkdirSync(path);
                                        }
                                      }
                                    }
                                    game_data.fs.writeFileSync('/'+ filename, new Buffer(data), null, flag_w, 0x1a4);
                                  }
                                };
                              }

                              var promises = game_data.files
                                                      .map(function (f) {
                                                             if (f && f.file) {
                                                               if (f.drive) {
                                                                 return fetch(f.file).then(mountat(f.drive));
                                                               } else if (f.mountpoint) {
                                                                 return fetch(f.file).then(saveat(f.mountpoint));
                                                               }
                                                             }
                                                             return null;
                                                           });
                              // this is kinda wrong; it really only applies when we're loading something created by Emscripten
                              if ('emulatorWASM' in game_data && game_data.emulatorWASM && 'WebAssembly' in window) {
                                promises.push(fetch({ title: "WASM Binary", url: game_data.emulatorWASM }).then(function (data) { game_data.wasmBinary = data; }));
                              }
                              Promise.all(promises).then(resolve, reject);
                            }
                          });
                        }
                      });
                    })
              .then(function (game_files) {
                      if (!game_data || splash.failed_loading) {
                        return null;
                      }
                      if (options.waitAfterDownloading) {
                        return new Promise(function (resolve, reject) {
                                             splash.setTitle("Press any key to continue...");
                                             splash.spinning = false;

                                             // stashes these event listeners so that we can remove them after
                                             window.addEventListener('keypress', k = keyevent(resolve));
                                             canvas.addEventListener('click', c = resolve);
                                             splash.splashElt.addEventListener('click', c);
                                           });
                      }
                      return Promise.resolve();
                    },
                    function () {
                      if (splash.failed_loading) {
                        return;
                      }
                      splash.setTitle("Failed to download data!");
                      splash.failed_loading = true;
                    })
              .then(function () {
                      if (!game_data || splash.failed_loading) {
                        return null;
                      }
                      splash.spinning = true;
                      window.removeEventListener('keypress', k);
                      canvas.removeEventListener('click', c);
                      splash.splashElt.removeEventListener('click', c);

                      // Don't let arrow, pg up/down, home, end affect page position
                      blockSomeKeys();
                      setupFullScreen();
                      disableRightClickContextMenu(canvas);

                      // Emscripten doesn't use the proper prefixed functions for fullscreen requests,
                      // so let's map the prefixed versions to the correct function.
                      canvas.requestPointerLock = getpointerlockenabler();

                      moveConfigToRoot(game_data.fs);

                      if (callbacks && callbacks.before_emulator) {
                        try {
                          callbacks.before_emulator();
                        } catch (x) {
                          console.log(x);
                        }
                      }

                      if ("runner" in game_data) {
                        if (game_data.runner == EmscriptenRunner || game_data.runner == MAMERunner) {
                          // this is a stupid hack. Emscripten-based
                          // apps currently need the runner to be set
                          // up first, then we can attach the
                          // script. The others have to do it the
                          // other way around.
                          runner = setup_runner();
                        }
                      }

                      if (game_data.emulatorJS) {
                        splash.setTitle("Launching System 7");
                        return attach_script(game_data.emulatorJS);
                      } else {
                        splash.setTitle("Non-system disk or disk error");
                      }
                      return null;
                    },
                    function () {
                      if (!game_data || splash.failed_loading) {
                        return null;
                      }
                      splash.setTitle("Invalid media, track 0 bad or unusable");
                      splash.failed_loading = true;
                    })
              .then(function () {
                      if (!game_data || splash.failed_loading) {
                        return null;
                      }
                      if ("runner" in game_data) {
                        if (!runner) {
                          runner = setup_runner();
                        }
                        runner.start();
                      }
                    });

       function setup_runner() {
         var runner = new game_data.runner(canvas, game_data);
         resizeCanvas(canvas, 1, game_data.nativeResolution, game_data.aspectRatio);
         runner.onStarted(function () {
                            splash.finished_loading = true;
                            splash.hide();
                            if (callbacks && callbacks.before_run) {
                              setTimeout(function() {
                                           callbacks.before_run();
                                         },
                                         0);
                            }
                          });
         runner.onReset(function () {
                          if (muted) {
                            runner.mute();
                          }
                        });
         return runner;
       }

       return this;
     };
     this.start = start;

     var formatSize = function (event) {
       if (event.lengthComputable)
         return "("+ (event.total ? (event.loaded / event.total * 100).toFixed(0)
                                  : "100") +
                "%; "+ formatBytes(event.loaded) +
                " of "+ formatBytes(event.total) +")";
       return "("+ formatBytes(event.loaded) +")";
     };

     var formatBytes = function (bytes, base10) {
         if (bytes === 0)
           return "0 B";
         var unit = base10 ? 1000 : 1024,
             units = base10 ? ["B", "kB","MB","GB","TB","PB","EB","ZB","YB"]
                            : ["B", "KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"],
             exp = parseInt((Math.log(bytes) / Math.log(unit))),
             size = bytes / Math.pow(unit, exp);
         return size.toFixed(1) +' '+ units[exp];
     };

     var fetch_file = function (title, url, rt, optional) {
       var needsCSS = splash.table.dataset.hasCustomCSS == "false";
       var row = addRow(splash.table);
       var titleCell = row[0], statusCell = row[1];
       titleCell.textContent = title;
       return new Promise(function (resolve, reject) {
                            var xhr = new XMLHttpRequest();
                            xhr.open('GET', url, true);
                            xhr.responseType = rt || 'arraybuffer';
                            xhr.onprogress = function (e) {
                                               titleCell.innerHTML = title +" <span style=\"font-size: smaller\">"+ formatSize(e) +"</span>";
                                             };
                            xhr.onload = function (e) {
                                           if (xhr.status === 200) {
                                             success();
                                             resolve(xhr.response);
                                           } else if (optional) {
                                             success();
                                             resolve(null);
                                           } else {
                                             failure();
                                             reject();
                                           }
                                         };
                            xhr.onerror = function (e) {
                                            if (optional) {
                                              success();
                                              resolve(null);
                                            } else {
                                              failure();
                                              reject();
                                            }
                                          };
                            function success() {
                              statusCell.textContent = "✔";
                              titleCell.parentNode.classList.add('emularity-download-success');
                              titleCell.textContent = title;
                              if (needsCSS) {
                                titleCell.style.fontWeight = 'bold';
                                titleCell.parentNode.style.backgroundColor = splash.getColor('foreground');
                                titleCell.parentNode.style.color = splash.getColor('background');
                              }
                            }
                            function failure() {
                              statusCell.textContent = "✘";
                              titleCell.parentNode.classList.add('emularity-download-failure');
                              titleCell.textContent = title;
                              if (needsCSS) {
                                titleCell.style.fontWeight = 'bold';
                                titleCell.parentNode.style.backgroundColor = splash.getColor('failure');
                                titleCell.parentNode.style.color = splash.getColor('background');
                              }
                            }
                            xhr.send();
                          });
     };

     function keyevent(resolve) {
       return function (e) {
                if (e.which == 32) {
                  e.preventDefault();
                  resolve();
                }
              };
     };

     var resizeCanvas = function (canvas, scale, resolution, aspectRatio) {
       if (scale && resolution) {
         // optimizeSpeed is the standardized value. different
         // browsers support different values; they will all ignore
         // values that they don't understand.
         canvas.style.imageRendering = '-moz-crisp-edges';
         canvas.style.imageRendering = '-o-crisp-edges';
         canvas.style.imageRendering = '-webkit-optimize-contrast';
         canvas.style.imageRendering = 'optimize-contrast';
         canvas.style.imageRendering = 'crisp-edges';
         canvas.style.imageRendering = 'pixelated';
         canvas.style.imageRendering = 'optimizeSpeed';

         canvas.style.width = resolution.width * scale +'px';
         canvas.style.height = resolution.height * scale +'px';
         canvas.width = resolution.width;
         canvas.height = resolution.height;
       }
     };

     var clearCanvas = function () {
       var context = canvas.getContext('2d');
       context.fillStyle = splash.getColor('background');
       context.fillRect(0, 0, canvas.width, canvas.height);
       console.log("canvas cleared");
     };

     function setupSplash(canvas, splash, globalOptions) {
       splash.splashElt = document.getElementById("emularity-splash-screen");
       if (!splash.splashElt) {
         splash.splashElt = document.createElement('div');
         splash.splashElt.classList.add("emularity-splash-screen");
         if (!globalOptions.hasCustomCSS) {
           splash.splashElt.style.position = 'absolute';
           splash.splashElt.style.top = '0';
           splash.splashElt.style.left = '0';
           splash.splashElt.style.right = '0';
           splash.splashElt.style.color = splash.getColor('foreground');
           splash.splashElt.style.backgroundColor = splash.getColor('background');
         }
         canvas.parentElement.appendChild(splash.splashElt);
       }

       splash.splashimg.classList.add("emularity-splash-image");
       if (!globalOptions.hasCustomCSS) {
         splash.splashimg.style.display = 'block';
         splash.splashimg.style.marginLeft = 'auto';
         splash.splashimg.style.marginRight = 'auto';
       }
       splash.splashElt.appendChild(splash.splashimg);

       splash.titleElt = document.createElement('span');
       splash.titleElt.classList.add("emularity-splash-title");
       if (!globalOptions.hasCustomCSS) {
         splash.titleElt.style.display = 'block';
         splash.titleElt.style.width = '100%';
         splash.titleElt.style.marginTop = "1em";
         splash.titleElt.style.marginBottom = "1em";
         splash.titleElt.style.textAlign = 'center';
         splash.titleElt.style.font = "24px sans-serif";
       }
       splash.titleElt.textContent = " ";
       splash.splashElt.appendChild(splash.titleElt);

       var table = document.getElementById("emularity-progress-indicator");
       if (!table) {
         table = document.createElement('table');
         table.classList.add("emularity-progress-indicator");
         table.dataset.hasCustomCSS = globalOptions.hasCustomCSS;
         if (!globalOptions.hasCustomCSS) {
           table.style.width = "75%";
           table.style.color = splash.getColor('foreground');
           table.style.backgroundColor = splash.getColor('background');
           table.style.marginLeft = 'auto';
           table.style.marginRight = 'auto';
           table.style.borderCollapse = 'separate';
           table.style.borderSpacing = "2px";
         }
         splash.splashElt.appendChild(table);
       }
       splash.table = table;
     }

     splash.setTitle = function (title) {
       splash.titleElt.textContent = title;
     };

     splash.hide = function () {
       splash.splashElt.style.display = 'none';
     };

     splash.getColor = function (name) {
       return name in splash.colors ? splash.colors[name]
                                    : defaultSplashColors[name];
     };

     var addRow = function (table) {
       var needsCSS = table.dataset.hasCustomCSS == "false";
       var row = table.insertRow(-1);
       if (needsCSS) {
         row.style.textAlign = 'center';
       }
       var cell = row.insertCell(-1);
       if (needsCSS) {
         cell.style.position = 'relative';
       }
       var titleCell = document.createElement('span');
       titleCell.classList.add("emularity-download-title");
       titleCell.textContent = '—';
       if (needsCSS) {
         titleCell.style.verticalAlign = 'center';
         titleCell.style.minHeight = "24px";
         titleCell.style.whiteSpace = "nowrap";
       }
       cell.appendChild(titleCell);
       var statusCell = document.createElement('span');
       statusCell.classList.add("emularity-download-status");
       if (needsCSS) {
         statusCell.style.position = 'absolute';
         statusCell.style.left = "0";
         statusCell.style.paddingLeft = "0.5em";
       }
       cell.appendChild(statusCell);
       return [titleCell, statusCell];
     };

     var drawsplash = function () {
       canvas.setAttribute('moz-opaque', '');
       if (!splash.splashimg.src) {
         splash.splashimg.src = "logo/emularity_color_small.png";
       }
     };

     function attach_script(js_url) {
       return new Promise(function (resolve, reject) {
                            var newScript;
                            function loaded(e) {
                              if (e.target == newScript) {
                                newScript.removeEventListener("load", loaded);
                                newScript.removeEventListener("error", failed);
                                resolve();
                              }
                            }
                            function failed(e) {
                              if (e.target == newScript) {
                                newScript.removeEventListener("load", loaded);
                                newScript.removeEventListener("error", failed);
                                reject();
                              }
                            }
                            if (js_url) {
                              var head = document.getElementsByTagName('head')[0];
                              newScript = document.createElement('script');
                              newScript.addEventListener("load", loaded);
                              newScript.addEventListener("error", failed);
                              newScript.type = 'text/javascript';
                              newScript.src = js_url;
                              head.appendChild(newScript);
                            }
                          });
     }

     function getpointerlockenabler() {
       return canvas.requestPointerLock || canvas.mozRequestPointerLock || canvas.webkitRequestPointerLock;
     }

     this.isfullscreensupported = function () {
        return !!(getfullscreenenabler());
     };

     function setupFullScreen() {
       var self = this;
       var fullScreenChangeHandler = function() {
                                       if (!(document.mozFullScreenElement || document.fullScreenElement)) {
                                         resizeCanvas(canvas, scale, css_resolution, aspectRatio);
                                       }
                                     };
       if ('onfullscreenchange' in document) {
         document.addEventListener('fullscreenchange', fullScreenChangeHandler);
       } else if ('onmozfullscreenchange' in document) {
         document.addEventListener('mozfullscreenchange', fullScreenChangeHandler);
       } else if ('onwebkitfullscreenchange' in document) {
         document.addEventListener('webkitfullscreenchange', fullScreenChangeHandler);
       }
     };

     this.requestFullScreen = function () {
       if (typeof Module == "object" && "requestFullScreen" in Module) {
         Module.requestFullScreen(1, 0);
       } else if (runner) {
         runner.requestFullScreen();
       }
     };

     /**
       * Prevents page navigation keys such as page up/page down from
       * moving the page while the user is playing.
       */
     function blockSomeKeys() {
       function keypress (e) {
         if (e.which >= 33 && e.which <= 40) {
           e.preventDefault();
           return false;
         }
         return true;
       }
       window.onkeydown = keypress;
     }

     /**
       * Disables the right click menu for the given element.
       */
     function disableRightClickContextMenu(element) {
       element.addEventListener('contextmenu',
                                function (e) {
                                  if (e.button == 2) {
                                    // Block right-click menu thru preventing default action.
                                    e.preventDefault();
                                  }
                                });
     }
   };

   /**
    * misc
    */
   function getfullscreenenabler() {
     return canvas.requestFullScreen || canvas.webkitRequestFullScreen || canvas.mozRequestFullScreen;
   }

   function BFSOpenZip(loadedData) {
       return new BrowserFS.FileSystem.ZipFS(loadedData);
   };

   // This is such a hack. We're not calling the BrowserFS api
   // "correctly", so we have to synthesize these flags ourselves
   var flag_r = { isReadable: function() { return true; },
                  isWriteable: function() { return false; },
                  isTruncating: function() { return false; },
                  isAppendable: function() { return false; },
                  isSynchronous: function() { return false; },
                  isExclusive: function() { return false; },
                  pathExistsAction: function() { return 0; },
                  pathNotExistsAction: function() { return 1; }
                };
   var flag_w = { isReadable: function() { return false; },
                  isWriteable: function() { return true; },
                  isTruncating: function() { return false; },
                  isAppendable: function() { return false; },
                  isSynchronous: function() { return false; },
                  isExclusive: function() { return false; },
                  pathExistsAction: function() { return 0; },
                  pathNotExistsAction: function() { return 3; }
                };

   /**
    * Searches for dosbox.conf, and moves it to '/dosbox.conf' so dosbox uses it.
    */
   function moveConfigToRoot(fs) {
     var dosboxConfPath = null;
     // Recursively search for dosbox.conf.
     function searchDirectory(dirPath) {
       fs.readdirSync(dirPath).forEach(function(item) {
         if (dosboxConfPath) {
           return;
         }
         // Avoid infinite recursion by ignoring these entries, which exist at
         // the root.
         if (item === '.' || item === '..') {
           return;
         }
         // Append '/' between dirPath and the item's name... unless dirPath
         // already ends in it (which always occurs if dirPath is the root, '/').
         var itemPath = dirPath + (dirPath[dirPath.length - 1] !== '/' ? "/" : "") + item,
             itemStat = fs.statSync(itemPath);
         if (itemStat.isDirectory(itemStat.mode)) {
           searchDirectory(itemPath);
         } else if (item === 'dosbox.conf') {
           dosboxConfPath = itemPath;
         }
       });
     }

     searchDirectory('/');

     if (dosboxConfPath !== null) {
       fs.writeFileSync('/dosbox.conf',
                        fs.readFileSync(dosboxConfPath, null, flag_r),
                        null, flag_w, 0x1a4);
     }
   };

   function extend(a, b) {
     if (a === null)
       return b;
     if (b === null)
       return a;
     var ta = typeof a,
         tb = typeof b;
     if (ta !== tb) {
       if (ta === 'undefined')
         return b;
       if (tb === 'undefined')
         return a;
       throw new Error("Cannot extend an "+ ta +" with an "+ tb);
     }
     if (Array.isArray(a))
       return a.concat(b);
     if (ta === 'object') {
       Object.keys(b).forEach(function (k) {
                                a[k] = extend(k in a ? a[k] : undefined, b[k]);
                              });
       return a;
     }
     return b;
   }

   function dict_from_xml(xml) {
     if (xml instanceof XMLDocument) {
       xml = xml.documentElement;
     }
     var dict = {};
     var len = xml.childNodes.length, i;
     for (i = 0; i < len; i++) {
       var node = xml.childNodes[i];
       dict[node.nodeName] = node.textContent;
     }
     return dict;
   }

   function list_from_xml(xml) {
     if (xml instanceof XMLDocument) {
       xml = xml.documentElement;
     }
     return Array.prototype.slice.call(xml.childNodes);
   }

   function files_from_filelist(xml) {
     return list_from_xml(xml).filter(function (node) {
                                        return "getAttribute" in node;
                                      })
                              .map(function (node) {
                                     var file = dict_from_xml(node);
                                     file.name = node.getAttribute("name");
                                     return file;
                              });
   }

   function files_with_ext_from_filelist(xml, ext) {
     if (!ext) {
       return [];
     }
     if (!ext.startsWith('.')) {
       ext = '.'+ ext;
     }
     ext = ext.toLowerCase();
     return files_from_filelist(xml).filter(function (file) {
                                              return file.name.toLowerCase().endsWith(ext);
                                            });
   }

   function meta_props_matching(meta, regex) {
     if (typeof regex == "string")
       regex = RegExp(regex);
     return Object.keys(meta).map(function (k) {
                                    let match = regex.exec(k);
                                    if (match)
                                      return [k, match];
                                    return null;
                                  })
                             .filter(function (result) {
                               return !!result;
                             });
   }

   function _SDL_CreateRGBSurfaceFrom(pixels, width, height, depth, pitch, rmask, gmask, bmask, amask) {
     // TODO: Actually fill pixel data to created surface.
     // TODO: Take into account depth and pitch parameters.
     // console.log('TODO: Partially unimplemented SDL_CreateRGBSurfaceFrom called!');
     var surface = SDL.makeSurface(width, height, 0, false, 'CreateRGBSurfaceFrom', rmask, gmask, bmask, amask);

     var surfaceData = SDL.surfaces[surface];
     var surfaceImageData = surfaceData.ctx.getImageData(0, 0, width, height);
     var surfacePixelData = surfaceImageData.data;

     // Fill pixel data to created surface.
     // Supports SDL_PIXELFORMAT_RGBA8888 and SDL_PIXELFORMAT_RGB888
     var channels = amask ? 4 : 3; // RGBA8888 or RGB888
     for (var pixelOffset = 0; pixelOffset < width*height; pixelOffset++) {
       surfacePixelData[pixelOffset*4+0] = HEAPU8[pixels + (pixelOffset*channels+0)]; // R
       surfacePixelData[pixelOffset*4+1] = HEAPU8[pixels + (pixelOffset*channels+1)]; // G
       surfacePixelData[pixelOffset*4+2] = HEAPU8[pixels + (pixelOffset*channels+2)]; // B
       surfacePixelData[pixelOffset*4+3] = amask ? HEAPU8[pixels + (pixelOffset*channels+3)] : 0xff; // A
     };

     surfaceData.ctx.putImageData(surfaceImageData, 0, 0);

     return surface;
   }

   window.IALoader = IALoader;
   window.DosBoxLoader = DosBoxLoader;
   window.JSMESSLoader = MAMELoader; // depreciated; just for backwards compatibility
   window.JSMAMELoader = MAMELoader; // ditto
   window.MAMELoader = MAMELoader;
   window.SAELoader = SAELoader;
   window.PCELoader = PCELoader;
   window.Emulator = Emulator;
   window._SDL_CreateRGBSurfaceFrom = _SDL_CreateRGBSurfaceFrom;
 })(typeof Promise === 'undefined' ? ES6Promise.Promise : Promise);

// legacy
var JSMESS = JSMESS || {};
JSMESS.ready = function (f) { f(); };
