include/core/rom.hpp

   1 #ifndef _rom__hpp__included__
   2 #define _rom__hpp__included__
   3
   4 #include <string>
   5 #include <map>
   6 #include <vector>
   7 #include <stdexcept>
   8 #include "core/misc.hpp"
   9 #include "core/rom-small.hpp"
  10 #include "interface/romtype.hpp"
  11 #include "library/fileimage.hpp"
  12
  13 //ROM request.
  14 struct rom_request
  15 {
  16         //List of core types.
  17         std::vector<core_type*> cores;
  18         //Selected core (default core on call).
  19         bool core_guessed;
  20         size_t selected;
  21         //Filename selected (on entry, filename hint).
  22         bool has_slot[ROM_SLOT_COUNT];
  23         bool guessed[ROM_SLOT_COUNT];
  24         std::string filename[ROM_SLOT_COUNT];
  25         std::string hash[ROM_SLOT_COUNT];
  26         std::string hashxml[ROM_SLOT_COUNT];
  27         //Canceled flag.
  28         bool canceled;
  29 };
  30
  31 /**
  32  * ROM loaded into memory.
  33  */
  34 struct loaded_rom
  35 {
  36 /**
  37  * Create blank ROM
  38  */
  39         loaded_rom() throw();
  40 /**
  41  * Take in ROM filename (or a bundle) and load it to memory.
  42  *
  43  * parameter file: The file to load
  44  * parameter tmpprefer: The core name to prefer.
  45  * throws std::bad_alloc: Not enough memory.
  46  * throws std::runtime_error: Loading ROM file failed.
  47  */
  48         loaded_rom(const std::string& file, const std::string& tmpprefer = "") throw(std::bad_alloc,
  49                 std::runtime_error);
  50 /**
  51  * Take a ROM and load it.
  52  */
  53         loaded_rom(const std::string& file, const std::string& core, const std::string& type,
  54                 const std::string& region);
  55 /**
  56  * Load a multi-file ROM.
  57  */
  58         loaded_rom(const std::string file[ROM_SLOT_COUNT], const std::string& core, const std::string& type,
  59                 const std::string& region);
  60 /**
  61  * Take in ROM filename and load it to memory with specified type.
  62  *
  63  * parameter file: The file to load
  64  * parameter ctype: The core type to use.
  65  * throws std::bad_alloc: Not enough memory.
  66  * throws std::runtime_error: Loading ROM file failed.
  67  */
  68         loaded_rom(const std::string& file, core_type& ctype) throw(std::bad_alloc, std::runtime_error);
  69 /**
  70  * Loaded main ROM
  71  */
  72         fileimage::image romimg[ROM_SLOT_COUNT];
  73 /**
  74  * Loaded main ROM XML
  75  */
  76         fileimage::image romxml[ROM_SLOT_COUNT];
  77 /**
  78  * MSU-1 base.
  79  */
  80         std::string msu1_base;
  81 /**
  82  * Load filename.
  83  */
  84         std::string load_filename;
  85 /**
  86  * Switches the active cartridge to this cartridge. The compatiblity between selected region and original region
  87  * is checked. Region is updated after cartridge has been loaded.
  88  *
  89  * throws std::bad_alloc: Not enough memory
  90  * throws std::runtime_error: Switching cartridges failed.
  91  */
  92         void load(std::map<std::string, std::string>& settings, uint64_t rtc_sec, uint64_t rtc_subsec)
  93                 throw(std::bad_alloc, std::runtime_error);
  94 /**
  95  * Saves core state into buffer. WARNING: This takes emulated time.
  96  *
  97  * returns: The saved state.
  98  * throws std::bad_alloc: Not enough memory.
  99  */
 100         std::vector<char> save_core_state(bool nochecksum = false) throw(std::bad_alloc, std::runtime_error);
 101
 102 /**
 103  * Loads core state from buffer.
 104  *
 105  * parameter buf: The buffer containing the state.
 106  * throws std::runtime_error: Loading state failed.
 107  */
 108         void load_core_state(const std::vector<char>& buf, bool nochecksum = false) throw(std::runtime_error);
 109
 110 /**
 111  * Is file a gamepak?
 112  *
 113  * parameter filename: The file to probe.
 114  * retruns: True if gamepak, false if not.
 115  * throws std::runtime_error: No such file.
 116  */
 117         static bool is_gamepak(const std::string& filename) throw(std::bad_alloc, std::runtime_error);
 118
 119 /**
 120  * Get internal type representation.
 121  */
 122         core_type& get_internal_rom_type() { return *rtype; }
 123 /**
 124  * Get internal region representation.
 125  */
 126         core_region& get_internal_region() { return *region; }
 127 /**
 128  * Is same ROM type?
 129  */
 130         bool is_of_type(core_type& type) { return (rtype == &type); }
 131 /**
 132  * Get gametype of this ROM.
 133  */
 134         core_sysregion& get_sysregion() { return rtype->combine_region(*region); }
 135 /**
 136  * Set internal region representation.
 137  */
 138         void set_internal_region(core_region& reg) { region = &reg; }
 139
 140         //ROM methods.
 141         std::string get_core_identifier() { return rtype->get_core_identifier(); }
 142         std::pair<uint32_t, uint32_t> get_scale_factors(uint32_t width, uint32_t height)
 143         {
 144                 return rtype->get_scale_factors(width, height);
 145         }
 146         const std::string& get_hname() { return rtype->get_hname(); }
 147         core_sysregion& combine_region(core_region& reg) { return rtype->combine_region(reg); }
 148         bool isnull() { return !rtype || rtype->isnull(); }
 149         std::vector<std::string> get_trace_cpus() { return rtype->get_trace_cpus(); }
 150         controller_set controllerconfig(std::map<std::string, std::string>& settings)
 151         {
 152                 return rtype->controllerconfig(settings);
 153         }
 154         core_setting_group& get_settings() { return rtype->get_settings(); }
 155         std::set<std::string> srams() { return rtype->srams(); }
 156         double get_PAR() { return rtype->get_PAR(); }
 157         std::string get_systemmenu_name() { return rtype->get_systemmenu_name(); }
 158         unsigned action_flags(unsigned id) { return rtype->action_flags(id); }
 159         std::set<const interface_action*> get_actions() { return rtype->get_actions(); }
 160         void execute_action(unsigned id, const std::vector<interface_action_paramval>& p)
 161         {
 162                 return rtype->execute_action(id, p);
 163         }
 164         std::pair<unsigned, unsigned> lightgun_scale() { return rtype->lightgun_scale(); }
 165         const interface_device_reg* get_registers() { return rtype->get_registers(); }
 166         bool get_pflag() { return rtype->get_pflag(); }
 167         void set_pflag(bool pflag) { rtype->set_pflag(pflag); }
 168         std::pair<uint64_t, uint64_t> get_bus_map() { return rtype->get_bus_map(); }
 169         std::list<core_region*> get_regions() { return rtype->get_regions(); }
 170         const std::string& get_iname() { return rtype->get_iname(); }
 171         std::map<std::string, std::vector<char>> save_sram() throw(std::bad_alloc) { return rtype->save_sram(); }
 172         void load_sram(std::map<std::string, std::vector<char>>& sram) throw(std::bad_alloc)
 173         {
 174                 rtype->load_sram(sram);
 175         }
 176         std::list<core_vma_info> vma_list() { return rtype->vma_list(); }
 177         framebuffer::raw& draw_cover() { return rtype->draw_cover(); }
 178         int reset_action(bool hard) { return rtype->reset_action(hard); }
 179         void pre_emulate_frame(portctrl::frame& cf) { return rtype->pre_emulate_frame(cf); }
 180         void emulate() { rtype->emulate(); }
 181         void runtosave() { rtype->runtosave(); }
 182         std::pair<uint32_t, uint32_t> get_audio_rate() { return rtype->get_audio_rate(); }
 183         void set_debug_flags(uint64_t addr, unsigned flags_set, unsigned flags_clear)
 184         {
 185                 return rtype->set_debug_flags(addr, flags_set, flags_clear);
 186         }
 187         void set_cheat(uint64_t addr, uint64_t value, bool set)
 188         {
 189                 return rtype->set_cheat(addr, value, set);
 190         }
 191         void debug_reset()
 192         {
 193                 rtype->debug_reset();
 194         }
 195         //Region methods.
 196         const std::string& orig_region_get_iname() { return orig_region->get_iname(); }
 197         const std::string& orig_region_get_hname() { return orig_region->get_hname(); }
 198         const std::string& region_get_iname() { return region->get_iname(); }
 199         const std::string& region_get_hname() { return region->get_hname(); }
 200         double region_approx_framerate() { return region->approx_framerate(); }
 201         void region_fill_framerate_magic(uint64_t* magic) { region->fill_framerate_magic(magic); }
 202         bool region_compatible_with(core_region& run)
 203         {
 204                 return orig_region && orig_region->compatible_with(run);
 205         }
 206 private:
 207 /**
 208  * ROM type
 209  */
 210         core_type* rtype;
 211 /**
 212  * ROM region (this is the currently active region).
 213  */
 214         core_region* region;
 215 /**
 216  * ROM original region (this is the region ROM is loaded as).
 217  */
 218         core_region* orig_region;
 219 };
 220
 221 /**
 222  * Get major type and region of loaded ROM.
 223  *
 224  * returns: Tuple (ROM type, ROM region) of currently loaded ROM.
 225  */
 226 std::pair<core_type*, core_region*> get_current_rom_info() throw();
 227
 228 /**
 229  * Read SRAMs from command-line and and load the files.
 230  *
 231  * parameter cmdline: Command line
 232  * returns: The loaded SRAM contents.
 233  * throws std::bad_alloc: Out of memory.
 234  * throws std::runtime_error: Failed to load.
 235  */
 236 std::map<std::string, std::vector<char>> load_sram_commandline(const std::vector<std::string>& cmdline)
 237         throw(std::bad_alloc, std::runtime_error);
 238
 239 /**
 240  * Set the hasher callback.
 241  */
 242 void set_hasher_callback(std::function<void(uint64_t, uint64_t)> cb);
 243
 244 struct romload_request
 245 {
 246         //Pack file to load. Overrides everything else.
 247         std::string packfile;
 248         //Single file to load to default slot.
 249         std::string singlefile;
 250         //Core and system. May be blank.
 251         std::string core;
 252         std::string system;
 253         std::string region;
 254         //Files to load.
 255         std::string files[ROM_SLOT_COUNT];
 256 };
 257
 258 bool load_null_rom();
 259 bool _load_new_rom(const romload_request& req);
 260 bool reload_active_rom();
 261 regex_results get_argument(const std::vector<std::string>& cmdline, const std::string& regexp);
 262 std::string get_requested_core(const std::vector<std::string>& cmdline);
 263 loaded_rom construct_rom(const std::string& movie_filename, const std::vector<std::string>& cmdline);
 264 void try_guess_roms(rom_request& req);
 265 void record_filehash(const std::string& file, uint64_t prefix, const std::string& hash);
 266 std::string try_to_guess_rom(const std::string& hint, const std::string& hash, const std::string& xhash,
 267         core_type& type, unsigned i);
 268
 269
 270 //Map of preferred cores for each extension and type.
 271 extern std::map<std::string, core_type*> preferred_core;
 272 //Main hasher
 273 extern fileimage::hash lsnes_image_hasher;
 274
 275
 276 #endif