?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Mark the core methods that should be idempotent as const
[lsnes.git] / src / emulation / bsnes-legacy / core.cpp
blobf68f89349108d7755d7f476a87cf9f07a7c2fc49
1 /*************************************************************************
2 * Copyright (C) 2011-2013 by Ilari Liusvaara *
3 * *
4 * This program is free software: you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation, either version 3 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
16 *************************************************************************/
17 #include "lsnes.hpp"
18 #include <sstream>
19 #include <map>
20 #include <string>
21 #include <cctype>
22 #include <vector>
23 #include <fstream>
24 #include <climits>
25 #include "core/audioapi.hpp"
26 #include "core/misc.hpp"
27 #include "core/command.hpp"
28 #include "core/controllerframe.hpp"
29 #include "core/dispatch.hpp"
30 #include "core/framebuffer.hpp"
31 #include "core/instance.hpp"
32 #include "core/settings.hpp"
33 #include "core/messages.hpp"
34 #include "interface/cover.hpp"
35 #include "interface/romtype.hpp"
36 #include "interface/setting.hpp"
37 #include "interface/callbacks.hpp"
38 #include "library/framebuffer-pixfmt-lrgb.hpp"
39 #include "library/hex.hpp"
40 #include "library/string.hpp"
41 #include "library/portctrl-data.hpp"
42 #include "library/memoryspace.hpp"
43 #include "library/framebuffer.hpp"
44 #include "library/lua-base.hpp"
45 #include "lua/internal.hpp"
46 #ifdef BSNES_HAS_DEBUGGER
47 #define DEBUGGER
48 #endif
49 #include <snes/snes.hpp>
50 #include <gameboy/gameboy.hpp>
51 #include LIBSNES_INCLUDE_FILE
52
53 #define DURATION_NTSC_FRAME 357366
54 #define DURATION_NTSC_FIELD 357368
55 #define DURATION_PAL_FRAME 425568
56 #define DURATION_PAL_FIELD 425568
57 #define ROM_TYPE_NONE 0
58 #define ROM_TYPE_SNES 1
59 #define ROM_TYPE_BSX 2
60 #define ROM_TYPE_BSXSLOTTED 3
61 #define ROM_TYPE_SUFAMITURBO 4
62 #define ROM_TYPE_SGB 5
63
64 #define ADDR_KIND_ALL -1
65 #define ADDR_KIND_NONE -2
66
67 namespace
68 {
69 bool p1disable = false;
70 bool do_hreset_flag = false;
71 long do_reset_flag = -1;
72 bool support_hreset = false;
73 bool support_dreset = false;
74 bool save_every_frame = false;
75 bool have_saved_this_frame = false;
76 int16_t blanksound[1070] = {0};
77 int16_t soundbuf[8192] = {0};
78 size_t soundbuf_fill = 0;
79 bool last_hires = false;
80 bool last_interlace = false;
81 bool last_PAL = false;
82 bool disable_breakpoints = false;
83 uint64_t trace_counter;
84 bool trace_cpu_enable;
85 bool trace_smp_enable;
86 bool trace_sa1_enable;
87 SNES::Interface* old;
88 bool stepping_into_save;
89 bool video_refresh_done;
90 bool forced_hook = false;
91 std::map<int16_t, std::pair<uint64_t, uint64_t>> ptrmap;
92 uint32_t cover_fbmem[512 * 448];
93 //Delay reset.
94 unsigned long long delayreset_cycles_run;
95 unsigned long long delayreset_cycles_target;
96
97 //Framebuffer.
98 struct framebuffer::info cover_fbinfo = {
99 &framebuffer::pixfmt_lrgb, //Format.
100 (char*)cover_fbmem, //Memory.
101 512, 448, 2048, //Physical size.
102 512, 448, 2048, //Logical size.
103 0, 0 //Offset.
104 };
105
106 struct interface_device_reg snes_registers[] = {
107 {"pbpc", []() -> uint64_t { return SNES::cpu.regs.pc; }, [](uint64_t v) { SNES::cpu.regs.pc = v; }},
108 {"pb", []() -> uint64_t { return SNES::cpu.regs.pc >> 16; },
109 [](uint64_t v) { SNES::cpu.regs.pc = (v << 16) | (SNES::cpu.regs.pc & 0xFFFF); }},
110 {"pc", []() -> uint64_t { return SNES::cpu.regs.pc & 0xFFFF; },
111 [](uint64_t v) { SNES::cpu.regs.pc = (v & 0xFFFF) | (SNES::cpu.regs.pc & ~0xFFFF); }},
112 {"r0", []() -> uint64_t { return SNES::cpu.regs.r[0]; }, [](uint64_t v) { SNES::cpu.regs.r[0] = v; }},
113 {"r1", []() -> uint64_t { return SNES::cpu.regs.r[1]; }, [](uint64_t v) { SNES::cpu.regs.r[1] = v; }},
114 {"r2", []() -> uint64_t { return SNES::cpu.regs.r[2]; }, [](uint64_t v) { SNES::cpu.regs.r[2] = v; }},
115 {"r3", []() -> uint64_t { return SNES::cpu.regs.r[3]; }, [](uint64_t v) { SNES::cpu.regs.r[3] = v; }},
116 {"r4", []() -> uint64_t { return SNES::cpu.regs.r[4]; }, [](uint64_t v) { SNES::cpu.regs.r[4] = v; }},
117 {"r5", []() -> uint64_t { return SNES::cpu.regs.r[5]; }, [](uint64_t v) { SNES::cpu.regs.r[5] = v; }},
118 {"a", []() -> uint64_t { return SNES::cpu.regs.a; }, [](uint64_t v) { SNES::cpu.regs.a = v; }},
119 {"x", []() -> uint64_t { return SNES::cpu.regs.x; }, [](uint64_t v) { SNES::cpu.regs.x = v; }},
120 {"y", []() -> uint64_t { return SNES::cpu.regs.y; }, [](uint64_t v) { SNES::cpu.regs.y = v; }},
121 {"z", []() -> uint64_t { return SNES::cpu.regs.z; }, [](uint64_t v) { SNES::cpu.regs.z = v; }},
122 {"s", []() -> uint64_t { return SNES::cpu.regs.s; }, [](uint64_t v) { SNES::cpu.regs.s = v; }},
123 {"d", []() -> uint64_t { return SNES::cpu.regs.d; }, [](uint64_t v) { SNES::cpu.regs.d = v; }},
124 {"db", []() -> uint64_t { return SNES::cpu.regs.db; }, [](uint64_t v) { SNES::cpu.regs.db = v; }},
125 {"p", []() -> uint64_t { return SNES::cpu.regs.p; }, [](uint64_t v) { SNES::cpu.regs.p = v; }},
126 {"e", []() -> uint64_t { return SNES::cpu.regs.e; }, [](uint64_t v) { SNES::cpu.regs.e = v; }},
127 {"irq", []() -> uint64_t { return SNES::cpu.regs.irq; }, [](uint64_t v) { SNES::cpu.regs.irq = v; }},
128 {"wai", []() -> uint64_t { return SNES::cpu.regs.wai; }, [](uint64_t v) { SNES::cpu.regs.wai = v; }},
129 {"mdr", []() -> uint64_t { return SNES::cpu.regs.mdr; }, [](uint64_t v) { SNES::cpu.regs.mdr = v; }},
130 {"vector", []() -> uint64_t { return SNES::cpu.regs.vector; },
131 [](uint64_t v) { SNES::cpu.regs.vector = v; }},
132 {"aa", []() -> uint64_t { return SNES::cpu.aa; }, [](uint64_t v) { SNES::cpu.aa = v; }},
133 {"rd", []() -> uint64_t { return SNES::cpu.rd; }, [](uint64_t v) { SNES::cpu.rd = v; }},
134 {"sp", []() -> uint64_t { return SNES::cpu.sp; }, [](uint64_t v) { SNES::cpu.sp = v; }},
135 {"dp", []() -> uint64_t { return SNES::cpu.dp; }, [](uint64_t v) { SNES::cpu.dp = v; }},
136 {"p_n", []() -> uint64_t { return SNES::cpu.regs.p.n; }, [](uint64_t v) { SNES::cpu.regs.p.n = v; },
137 true},
138 {"p_v", []() -> uint64_t { return SNES::cpu.regs.p.v; }, [](uint64_t v) { SNES::cpu.regs.p.v = v; },
139 true},
140 {"p_m", []() -> uint64_t { return SNES::cpu.regs.p.m; }, [](uint64_t v) { SNES::cpu.regs.p.m = v; },
141 true},
142 {"p_x", []() -> uint64_t { return SNES::cpu.regs.p.x; }, [](uint64_t v) { SNES::cpu.regs.p.x = v; },
143 true},
144 {"p_d", []() -> uint64_t { return SNES::cpu.regs.p.d; }, [](uint64_t v) { SNES::cpu.regs.p.d = v; },
145 true},
146 {"p_i", []() -> uint64_t { return SNES::cpu.regs.p.i; }, [](uint64_t v) { SNES::cpu.regs.p.i = v; },
147 true},
148 {"p_z", []() -> uint64_t { return SNES::cpu.regs.p.z; }, [](uint64_t v) { SNES::cpu.regs.p.z = v; },
149 true},
150 {"p_c", []() -> uint64_t { return SNES::cpu.regs.p.c; }, [](uint64_t v) { SNES::cpu.regs.p.c = v; },
151 true},
152 {"hcounter", []() -> uint64_t { return SNES::cpu.hcounter(); }, [](uint64_t v) {}, false},
153 {"vcounter", []() -> uint64_t { return SNES::cpu.vcounter(); }, [](uint64_t v) {}, false},
154 {"sa1_pbpc", []() -> uint64_t { return SNES::sa1.regs.pc; },
155 [](uint64_t v) { SNES::sa1.regs.pc = v; }},
156 {"sa1_pb", []() -> uint64_t { return SNES::sa1.regs.pc >> 16; },
157 [](uint64_t v) { SNES::sa1.regs.pc = (v << 16) | (SNES::sa1.regs.pc & 0xFFFF); }},
158 {"sa1_pc", []() -> uint64_t { return SNES::sa1.regs.pc & 0xFFFF; },
159 [](uint64_t v) { SNES::sa1.regs.pc = (v & 0xFFFF) | (SNES::sa1.regs.pc & ~0xFFFF); }},
160 {"sa1_r0", []() -> uint64_t { return SNES::sa1.regs.r[0]; },
161 [](uint64_t v) { SNES::sa1.regs.r[0] = v; }},
162 {"sa1_r1", []() -> uint64_t { return SNES::sa1.regs.r[1]; },
163 [](uint64_t v) { SNES::sa1.regs.r[1] = v; }},
164 {"sa1_r2", []() -> uint64_t { return SNES::sa1.regs.r[2]; },
165 [](uint64_t v) { SNES::sa1.regs.r[2] = v; }},
166 {"sa1_r3", []() -> uint64_t { return SNES::sa1.regs.r[3]; },
167 [](uint64_t v) { SNES::sa1.regs.r[3] = v; }},
168 {"sa1_r4", []() -> uint64_t { return SNES::sa1.regs.r[4]; },
169 [](uint64_t v) { SNES::sa1.regs.r[4] = v; }},
170 {"sa1_r5", []() -> uint64_t { return SNES::sa1.regs.r[5]; },
171 [](uint64_t v) { SNES::sa1.regs.r[5] = v; }},
172 {"sa1_a", []() -> uint64_t { return SNES::sa1.regs.a; }, [](uint64_t v) { SNES::sa1.regs.a = v; }},
173 {"sa1_x", []() -> uint64_t { return SNES::sa1.regs.x; }, [](uint64_t v) { SNES::sa1.regs.x = v; }},
174 {"sa1_y", []() -> uint64_t { return SNES::sa1.regs.y; }, [](uint64_t v) { SNES::sa1.regs.y = v; }},
175 {"sa1_z", []() -> uint64_t { return SNES::sa1.regs.z; }, [](uint64_t v) { SNES::sa1.regs.z = v; }},
176 {"sa1_s", []() -> uint64_t { return SNES::sa1.regs.s; }, [](uint64_t v) { SNES::sa1.regs.s = v; }},
177 {"sa1_d", []() -> uint64_t { return SNES::sa1.regs.d; }, [](uint64_t v) { SNES::sa1.regs.d = v; }},
178 {"sa1_db", []() -> uint64_t { return SNES::sa1.regs.db; }, [](uint64_t v) { SNES::sa1.regs.db = v; }},
179 {"sa1_p", []() -> uint64_t { return SNES::sa1.regs.p; }, [](uint64_t v) { SNES::sa1.regs.p = v; }},
180 {"sa1_e", []() -> uint64_t { return SNES::sa1.regs.e; }, [](uint64_t v) { SNES::sa1.regs.e = v; }},
181 {"sa1_irq", []() -> uint64_t { return SNES::sa1.regs.irq; },
182 [](uint64_t v) { SNES::sa1.regs.irq = v; }},
183 {"sa1_wai", []() -> uint64_t { return SNES::sa1.regs.wai; },
184 [](uint64_t v) { SNES::sa1.regs.wai = v; }},
185 {"sa1_mdr", []() -> uint64_t { return SNES::sa1.regs.mdr; },
186 [](uint64_t v) { SNES::sa1.regs.mdr = v; }},
187 {"sa1_vector", []() -> uint64_t { return SNES::sa1.regs.vector; },
188 [](uint64_t v) { SNES::sa1.regs.vector = v; }},
189 {"sa1_aa", []() -> uint64_t { return SNES::sa1.aa; }, [](uint64_t v) { SNES::sa1.aa = v; }},
190 {"sa1_rd", []() -> uint64_t { return SNES::sa1.rd; }, [](uint64_t v) { SNES::sa1.rd = v; }},
191 {"sa1_sp", []() -> uint64_t { return SNES::sa1.sp; }, [](uint64_t v) { SNES::sa1.sp = v; }},
192 {"sa1_dp", []() -> uint64_t { return SNES::sa1.dp; }, [](uint64_t v) { SNES::sa1.dp = v; }},
193 {"sa1_p_n", []() -> uint64_t { return SNES::sa1.regs.p.n; },
194 [](uint64_t v) { SNES::sa1.regs.p.n = v; }, true},
195 {"sa1_p_v", []() -> uint64_t { return SNES::sa1.regs.p.v; },
196 [](uint64_t v) { SNES::sa1.regs.p.v = v; }, true},
197 {"sa1_p_m", []() -> uint64_t { return SNES::sa1.regs.p.m; },
198 [](uint64_t v) { SNES::sa1.regs.p.m = v; }, true},
199 {"sa1_p_x", []() -> uint64_t { return SNES::sa1.regs.p.x; },
200 [](uint64_t v) { SNES::sa1.regs.p.x = v; }, true},
201 {"sa1_p_d", []() -> uint64_t { return SNES::sa1.regs.p.d; },
202 [](uint64_t v) { SNES::sa1.regs.p.d = v; }, true},
203 {"sa1_p_i", []() -> uint64_t { return SNES::sa1.regs.p.i; },
204 [](uint64_t v) { SNES::sa1.regs.p.i = v; }, true},
205 {"sa1_p_z", []() -> uint64_t { return SNES::sa1.regs.p.z; },
206 [](uint64_t v) { SNES::sa1.regs.p.z = v; }, true},
207 {"sa1_p_c", []() -> uint64_t { return SNES::sa1.regs.p.c; },
208 [](uint64_t v) { SNES::sa1.regs.p.c = v; }, true},
209 {"hcounter", []() -> uint64_t { return SNES::cpu.hcounter(); }, [](uint64_t v) {}},
210 {"vcounter", []() -> uint64_t { return SNES::cpu.vcounter(); }, [](uint64_t v) {}},
211 #ifdef BSNES_IS_COMPAT
212 {"ppu_display_disabled", []() -> uint64_t { return SNES::ppu.regs.display_disabled; },
213 [](uint64_t v) { SNES::ppu.regs.display_disabled = v; }, true},
214 {"ppu_oam_priority", []() -> uint64_t { return SNES::ppu.regs.oam_priority; },
215 [](uint64_t v) { SNES::ppu.regs.oam_priority = v; }, true},
216 {"ppu_bg_tilesize[0]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[0]; },
217 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[0] = v; }, true},
218 {"ppu_bg_tilesize[1]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[1]; },
219 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[1] = v; }, true},
220 {"ppu_bg_tilesize[2]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[2]; },
221 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[2] = v; }, true},
222 {"ppu_bg_tilesize[3]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[3]; },
223 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[3] = v; }, true},
224 {"ppu_bg3_priority", []() -> uint64_t { return SNES::ppu.regs.bg3_priority; },
225 [](uint64_t v) { SNES::ppu.regs.bg3_priority = v; }, true},
226 {"ppu_mosaic_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[0]; },
227 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[0] = v; }, true},
228 {"ppu_mosaic_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[1]; },
229 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[1] = v; }, true},
230 {"ppu_mosaic_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[2]; },
231 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[2] = v; }, true},
232 {"ppu_mosaic_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[3]; },
233 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[3] = v; }, true},
234 {"ppu_vram_incmode", []() -> uint64_t { return SNES::ppu.regs.vram_incmode; },
235 [](uint64_t v) { SNES::ppu.regs.vram_incmode = v; }, true},
236 {"ppu_mode7_vflip", []() -> uint64_t { return SNES::ppu.regs.mode7_vflip; },
237 [](uint64_t v) { SNES::ppu.regs.mode7_vflip = v; }, true},
238 {"ppu_mode7_hflip", []() -> uint64_t { return SNES::ppu.regs.mode7_hflip; },
239 [](uint64_t v) { SNES::ppu.regs.mode7_hflip = v; }, true},
240 {"ppu_window1_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[0]; },
241 [](uint64_t v) { SNES::ppu.regs.window1_enabled[0] = v; }, true},
242 {"ppu_window1_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[1]; },
243 [](uint64_t v) { SNES::ppu.regs.window1_enabled[1] = v; }, true},
244 {"ppu_window1_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[2]; },
245 [](uint64_t v) { SNES::ppu.regs.window1_enabled[2] = v; }, true},
246 {"ppu_window1_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[3]; },
247 [](uint64_t v) { SNES::ppu.regs.window1_enabled[3] = v; }, true},
248 {"ppu_window1_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[4]; },
249 [](uint64_t v) { SNES::ppu.regs.window1_enabled[4] = v; }, true},
250 {"ppu_window1_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[5]; },
251 [](uint64_t v) { SNES::ppu.regs.window1_enabled[5] = v; }, true},
252 {"ppu_window1_invert[0]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[0]; },
253 [](uint64_t v) { SNES::ppu.regs.window1_invert[0] = v; }, true},
254 {"ppu_window1_invert[1]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[1]; },
255 [](uint64_t v) { SNES::ppu.regs.window1_invert[1] = v; }, true},
256 {"ppu_window1_invert[2]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[2]; },
257 [](uint64_t v) { SNES::ppu.regs.window1_invert[2] = v; }, true},
258 {"ppu_window1_invert[3]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[3]; },
259 [](uint64_t v) { SNES::ppu.regs.window1_invert[3] = v; }, true},
260 {"ppu_window1_invert[4]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[4]; },
261 [](uint64_t v) { SNES::ppu.regs.window1_invert[4] = v; }, true},
262 {"ppu_window1_invert[5]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[5]; },
263 [](uint64_t v) { SNES::ppu.regs.window1_invert[5] = v; }, true},
264 {"ppu_window2_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[0]; },
265 [](uint64_t v) { SNES::ppu.regs.window2_enabled[0] = v; }, true},
266 {"ppu_window2_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[1]; },
267 [](uint64_t v) { SNES::ppu.regs.window2_enabled[1] = v; }, true},
268 {"ppu_window2_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[2]; },
269 [](uint64_t v) { SNES::ppu.regs.window2_enabled[2] = v; }, true},
270 {"ppu_window2_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[3]; },
271 [](uint64_t v) { SNES::ppu.regs.window2_enabled[3] = v; }, true},
272 {"ppu_window2_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[4]; },
273 [](uint64_t v) { SNES::ppu.regs.window2_enabled[4] = v; }, true},
274 {"ppu_window2_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[5]; },
275 [](uint64_t v) { SNES::ppu.regs.window2_enabled[5] = v; }, true},
276 {"ppu_window2_invert[0]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[0]; },
277 [](uint64_t v) { SNES::ppu.regs.window2_invert[0] = v; }, true},
278 {"ppu_window2_invert[1]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[1]; },
279 [](uint64_t v) { SNES::ppu.regs.window2_invert[1] = v; }, true},
280 {"ppu_window2_invert[2]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[2]; },
281 [](uint64_t v) { SNES::ppu.regs.window2_invert[2] = v; }, true},
282 {"ppu_window2_invert[3]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[3]; },
283 [](uint64_t v) { SNES::ppu.regs.window2_invert[3] = v; }, true},
284 {"ppu_window2_invert[4]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[4]; },
285 [](uint64_t v) { SNES::ppu.regs.window2_invert[4] = v; }, true},
286 {"ppu_window2_invert[5]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[5]; },
287 [](uint64_t v) { SNES::ppu.regs.window2_invert[5] = v; }, true},
288 {"ppu_bg_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[0]; },
289 [](uint64_t v) { SNES::ppu.regs.bg_enabled[0] = v; }, true},
290 {"ppu_bg_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[1]; },
291 [](uint64_t v) { SNES::ppu.regs.bg_enabled[1] = v; }, true},
292 {"ppu_bg_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[2]; },
293 [](uint64_t v) { SNES::ppu.regs.bg_enabled[2] = v; }, true},
294 {"ppu_bg_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[3]; },
295 [](uint64_t v) { SNES::ppu.regs.bg_enabled[3] = v; }, true},
296 {"ppu_bg_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[4]; },
297 [](uint64_t v) { SNES::ppu.regs.bg_enabled[4] = v; }, true},
298 {"ppu_bgsub_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[0]; },
299 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[0] = v; }, true},
300 {"ppu_bgsub_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[1]; },
301 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[1] = v; }, true},
302 {"ppu_bgsub_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[2]; },
303 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[2] = v; }, true},
304 {"ppu_bgsub_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[3]; },
305 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[3] = v; }, true},
306 {"ppu_bgsub_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[4]; },
307 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[4] = v; }, true},
308 {"ppu_window_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[0]; },
309 [](uint64_t v) { SNES::ppu.regs.window_enabled[0] = v; }, true},
310 {"ppu_window_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[1]; },
311 [](uint64_t v) { SNES::ppu.regs.window_enabled[1] = v; }, true},
312 {"ppu_window_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[2]; },
313 [](uint64_t v) { SNES::ppu.regs.window_enabled[2] = v; }, true},
314 {"ppu_window_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[3]; },
315 [](uint64_t v) { SNES::ppu.regs.window_enabled[3] = v; }, true},
316 {"ppu_window_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[4]; },
317 [](uint64_t v) { SNES::ppu.regs.window_enabled[4] = v; }, true},
318 {"ppu_sub_window_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[0]; },
319 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[0] = v; }, true},
320 {"ppu_sub_window_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[1]; },
321 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[1] = v; }, true},
322 {"ppu_sub_window_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[2]; },
323 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[2] = v; }, true},
324 {"ppu_sub_window_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[3]; },
325 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[3] = v; }, true},
326 {"ppu_sub_window_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[4]; },
327 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[4] = v; }, true},
328 {"ppu_addsub_mode", []() -> uint64_t { return SNES::ppu.regs.addsub_mode; },
329 [](uint64_t v) { SNES::ppu.regs.addsub_mode = v; }, true},
330 {"ppu_direct_color", []() -> uint64_t { return SNES::ppu.regs.direct_color; },
331 [](uint64_t v) { SNES::ppu.regs.direct_color = v; }, true},
332 {"ppu_color_mode", []() -> uint64_t { return SNES::ppu.regs.color_mode; },
333 [](uint64_t v) { SNES::ppu.regs.color_mode = v; }, true},
334 {"ppu_color_halve", []() -> uint64_t { return SNES::ppu.regs.color_halve; },
335 [](uint64_t v) { SNES::ppu.regs.color_halve = v; }, true},
336 {"ppu_color_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[0]; },
337 [](uint64_t v) { SNES::ppu.regs.color_enabled[0] = v; }, true},
338 {"ppu_color_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[1]; },
339 [](uint64_t v) { SNES::ppu.regs.color_enabled[1] = v; }, true},
340 {"ppu_color_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[2]; },
341 [](uint64_t v) { SNES::ppu.regs.color_enabled[2] = v; }, true},
342 {"ppu_color_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[3]; },
343 [](uint64_t v) { SNES::ppu.regs.color_enabled[3] = v; }, true},
344 {"ppu_color_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[4]; },
345 [](uint64_t v) { SNES::ppu.regs.color_enabled[4] = v; }, true},
346 {"ppu_color_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[5]; },
347 [](uint64_t v) { SNES::ppu.regs.color_enabled[5] = v; }, true},
348 {"ppu_mode7_extbg", []() -> uint64_t { return SNES::ppu.regs.mode7_extbg; },
349 [](uint64_t v) { SNES::ppu.regs.mode7_extbg = v; }, true},
350 {"ppu_pseudo_hires", []() -> uint64_t { return SNES::ppu.regs.pseudo_hires; },
351 [](uint64_t v) { SNES::ppu.regs.pseudo_hires = v; }, true},
352 {"ppu_overscan", []() -> uint64_t { return SNES::ppu.regs.overscan; },
353 [](uint64_t v) { SNES::ppu.regs.overscan = v; }, true},
354 {"ppu_oam_interlace", []() -> uint64_t { return SNES::ppu.regs.oam_interlace; },
355 [](uint64_t v) { SNES::ppu.regs.oam_interlace = v; }, true},
356 {"ppu_interlace", []() -> uint64_t { return SNES::ppu.regs.interlace; },
357 [](uint64_t v) { SNES::ppu.regs.interlace = v; }, true},
358 {"ppu_latch_hcounter", []() -> uint64_t { return SNES::ppu.regs.latch_hcounter; },
359 [](uint64_t v) { SNES::ppu.regs.latch_hcounter = v; }, true},
360 {"ppu_latch_vcounter", []() -> uint64_t { return SNES::ppu.regs.latch_vcounter; },
361 [](uint64_t v) { SNES::ppu.regs.latch_vcounter = v; }, true},
362 {"ppu_counters_latched", []() -> uint64_t { return SNES::ppu.regs.counters_latched; },
363 [](uint64_t v) { SNES::ppu.regs.counters_latched = v; }, true},
364 {"ppu_time_over", []() -> uint64_t { return SNES::ppu.regs.time_over; },
365 [](uint64_t v) { SNES::ppu.regs.time_over = v; }, true},
366 {"ppu_range_over", []() -> uint64_t { return SNES::ppu.regs.range_over; },
367 [](uint64_t v) { SNES::ppu.regs.range_over = v; }, true},
368 {"ppu_ppu1_mdr", []() -> uint64_t { return SNES::ppu.regs.ppu1_mdr; },
369 [](uint64_t v) { SNES::ppu.regs.ppu1_mdr = v; }},
370 {"ppu_ppu2_mdr", []() -> uint64_t { return SNES::ppu.regs.ppu2_mdr; },
371 [](uint64_t v) { SNES::ppu.regs.ppu2_mdr = v; }},
372 {"ppu_bg_y[0]", []() -> uint64_t { return SNES::ppu.regs.bg_y[0]; },
373 [](uint64_t v) { SNES::ppu.regs.bg_y[0] = v; }},
374 {"ppu_bg_y[1]", []() -> uint64_t { return SNES::ppu.regs.bg_y[1]; },
375 [](uint64_t v) { SNES::ppu.regs.bg_y[1] = v; }},
376 {"ppu_bg_y[2]", []() -> uint64_t { return SNES::ppu.regs.bg_y[2]; },
377 [](uint64_t v) { SNES::ppu.regs.bg_y[2] = v; }},
378 {"ppu_bg_y[3]", []() -> uint64_t { return SNES::ppu.regs.bg_y[3]; },
379 [](uint64_t v) { SNES::ppu.regs.bg_y[3] = v; }},
380 {"ppu_ioamaddr", []() -> uint64_t { return SNES::ppu.regs.ioamaddr; },
381 [](uint64_t v) { SNES::ppu.regs.ioamaddr = v; }},
382 {"ppu_icgramaddr", []() -> uint64_t { return SNES::ppu.regs.icgramaddr; },
383 [](uint64_t v) { SNES::ppu.regs.icgramaddr = v; }},
384 {"ppu_display_brightness", []() -> uint64_t { return SNES::ppu.regs.display_brightness; },
385 [](uint64_t v) { SNES::ppu.regs.display_brightness = v; }},
386 {"ppu_oam_basesize", []() -> uint64_t { return SNES::ppu.regs.oam_basesize; },
387 [](uint64_t v) { SNES::ppu.regs.oam_basesize = v; }},
388 {"ppu_oam_nameselect", []() -> uint64_t { return SNES::ppu.regs.oam_nameselect; },
389 [](uint64_t v) { SNES::ppu.regs.oam_nameselect = v; }},
390 {"ppu_oam_tdaddr", []() -> uint64_t { return SNES::ppu.regs.oam_tdaddr; },
391 [](uint64_t v) { SNES::ppu.regs.oam_tdaddr = v; }},
392 {"ppu_oam_baseaddr", []() -> uint64_t { return SNES::ppu.regs.oam_baseaddr; },
393 [](uint64_t v) { SNES::ppu.regs.oam_baseaddr = v; }},
394 {"ppu_oam_addr", []() -> uint64_t { return SNES::ppu.regs.oam_addr; },
395 [](uint64_t v) { SNES::ppu.regs.oam_addr = v; }},
396 {"ppu_oam_firstsprite", []() -> uint64_t { return SNES::ppu.regs.oam_firstsprite; },
397 [](uint64_t v) { SNES::ppu.regs.oam_firstsprite = v; }},
398 {"ppu_oam_latchdata", []() -> uint64_t { return SNES::ppu.regs.oam_latchdata; },
399 [](uint64_t v) { SNES::ppu.regs.oam_latchdata = v; }},
400 {"ppu_bg_mode", []() -> uint64_t { return SNES::ppu.regs.bg_mode; },
401 [](uint64_t v) { SNES::ppu.regs.bg_mode = v; }},
402 {"ppu_mosaic_size", []() -> uint64_t { return SNES::ppu.regs.mosaic_size; },
403 [](uint64_t v) { SNES::ppu.regs.mosaic_size = v; }},
404 {"ppu_mosaic_countdown", []() -> uint64_t { return SNES::ppu.regs.mosaic_countdown; },
405 [](uint64_t v) { SNES::ppu.regs.mosaic_countdown = v; }},
406 {"ppu_bg_scaddr[0]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[0]; },
407 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[0] = v; }},
408 {"ppu_bg_scaddr[1]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[1]; },
409 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[1] = v; }},
410 {"ppu_bg_scaddr[2]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[2]; },
411 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[2] = v; }},
412 {"ppu_bg_scaddr[3]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[3]; },
413 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[3] = v; }},
414 {"ppu_bg_scsize[0]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[0]; },
415 [](uint64_t v) { SNES::ppu.regs.bg_scsize[0] = v; }},
416 {"ppu_bg_scsize[1]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[1]; },
417 [](uint64_t v) { SNES::ppu.regs.bg_scsize[1] = v; }},
418 {"ppu_bg_scsize[2]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[2]; },
419 [](uint64_t v) { SNES::ppu.regs.bg_scsize[2] = v; }},
420 {"ppu_bg_scsize[3]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[3]; },
421 [](uint64_t v) { SNES::ppu.regs.bg_scsize[3] = v; }},
422 {"ppu_bg_tdaddr[0]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[0]; },
423 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[0] = v; }},
424 {"ppu_bg_tdaddr[1]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[1]; },
425 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[1] = v; }},
426 {"ppu_bg_tdaddr[2]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[2]; },
427 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[2] = v; }},
428 {"ppu_bg_tdaddr[3]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[3]; },
429 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[3] = v; }},
430 {"ppu_bg_ofslatch", []() -> uint64_t { return SNES::ppu.regs.bg_ofslatch; },
431 [](uint64_t v) { SNES::ppu.regs.bg_ofslatch = v; }},
432 {"ppu_m7_hofs", []() -> uint64_t { return SNES::ppu.regs.m7_hofs; },
433 [](uint64_t v) { SNES::ppu.regs.m7_hofs = v; }},
434 {"ppu_m7_vofs", []() -> uint64_t { return SNES::ppu.regs.m7_vofs; },
435 [](uint64_t v) { SNES::ppu.regs.m7_vofs = v; }},
436 {"ppu_bg_hofs[0]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[0]; },
437 [](uint64_t v) { SNES::ppu.regs.bg_hofs[0] = v; }},
438 {"ppu_bg_hofs[1]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[1]; },
439 [](uint64_t v) { SNES::ppu.regs.bg_hofs[1] = v; }},
440 {"ppu_bg_hofs[2]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[2]; },
441 [](uint64_t v) { SNES::ppu.regs.bg_hofs[2] = v; }},
442 {"ppu_bg_hofs[3]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[3]; },
443 [](uint64_t v) { SNES::ppu.regs.bg_hofs[3] = v; }},
444 {"ppu_bg_vofs[0]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[0]; },
445 [](uint64_t v) { SNES::ppu.regs.bg_vofs[0] = v; }},
446 {"ppu_bg_vofs[1]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[1]; },
447 [](uint64_t v) { SNES::ppu.regs.bg_vofs[1] = v; }},
448 {"ppu_bg_vofs[2]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[2]; },
449 [](uint64_t v) { SNES::ppu.regs.bg_vofs[2] = v; }},
450 {"ppu_bg_vofs[3]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[3]; },
451 [](uint64_t v) { SNES::ppu.regs.bg_vofs[3] = v; }},
452 {"ppu_vram_mapping", []() -> uint64_t { return SNES::ppu.regs.vram_mapping; },
453 [](uint64_t v) { SNES::ppu.regs.vram_mapping = v; }},
454 {"ppu_vram_incsize", []() -> uint64_t { return SNES::ppu.regs.vram_incsize; },
455 [](uint64_t v) { SNES::ppu.regs.vram_incsize = v; }},
456 {"ppu_vram_addr", []() -> uint64_t { return SNES::ppu.regs.vram_addr; },
457 [](uint64_t v) { SNES::ppu.regs.vram_addr = v; }},
458 {"ppu_mode7_repeat", []() -> uint64_t { return SNES::ppu.regs.mode7_repeat; },
459 [](uint64_t v) { SNES::ppu.regs.mode7_repeat = v; }},
460 {"ppu_m7_latch", []() -> uint64_t { return SNES::ppu.regs.m7_latch; },
461 [](uint64_t v) { SNES::ppu.regs.m7_latch = v; }},
462 {"ppu_m7a", []() -> uint64_t { return SNES::ppu.regs.m7a; },
463 [](uint64_t v) { SNES::ppu.regs.m7a = v; }},
464 {"ppu_m7b", []() -> uint64_t { return SNES::ppu.regs.m7b; },
465 [](uint64_t v) { SNES::ppu.regs.m7b = v; }},
466 {"ppu_m7c", []() -> uint64_t { return SNES::ppu.regs.m7c; },
467 [](uint64_t v) { SNES::ppu.regs.m7c = v; }},
468 {"ppu_m7d", []() -> uint64_t { return SNES::ppu.regs.m7d; },
469 [](uint64_t v) { SNES::ppu.regs.m7d = v; }},
470 {"ppu_m7x", []() -> uint64_t { return SNES::ppu.regs.m7x; },
471 [](uint64_t v) { SNES::ppu.regs.m7x = v; }},
472 {"ppu_m7y", []() -> uint64_t { return SNES::ppu.regs.m7y; },
473 [](uint64_t v) { SNES::ppu.regs.m7y = v; }},
474 {"ppu_cgram_addr", []() -> uint64_t { return SNES::ppu.regs.cgram_addr; },
475 [](uint64_t v) { SNES::ppu.regs.cgram_addr = v; }},
476 {"ppu_cgram_latchdata", []() -> uint64_t { return SNES::ppu.regs.cgram_latchdata; },
477 [](uint64_t v) { SNES::ppu.regs.cgram_latchdata = v; }},
478 {"ppu_window1_left", []() -> uint64_t { return SNES::ppu.regs.window1_left; },
479 [](uint64_t v) { SNES::ppu.regs.window1_left = v; }},
480 {"ppu_window1_right", []() -> uint64_t { return SNES::ppu.regs.window1_right; },
481 [](uint64_t v) { SNES::ppu.regs.window1_right = v; }},
482 {"ppu_window2_left", []() -> uint64_t { return SNES::ppu.regs.window2_left; },
483 [](uint64_t v) { SNES::ppu.regs.window2_left = v; }},
484 {"ppu_window2_right", []() -> uint64_t { return SNES::ppu.regs.window2_right; },
485 [](uint64_t v) { SNES::ppu.regs.window2_right = v; }},
486 {"ppu_window_mask[0]", []() -> uint64_t { return SNES::ppu.regs.window_mask[0]; },
487 [](uint64_t v) { SNES::ppu.regs.window_mask[0] = v; }},
488 {"ppu_window_mask[1]", []() -> uint64_t { return SNES::ppu.regs.window_mask[1]; },
489 [](uint64_t v) { SNES::ppu.regs.window_mask[1] = v; }},
490 {"ppu_window_mask[2]", []() -> uint64_t { return SNES::ppu.regs.window_mask[2]; },
491 [](uint64_t v) { SNES::ppu.regs.window_mask[2] = v; }},
492 {"ppu_window_mask[3]", []() -> uint64_t { return SNES::ppu.regs.window_mask[3]; },
493 [](uint64_t v) { SNES::ppu.regs.window_mask[3] = v; }},
494 {"ppu_window_mask[4]", []() -> uint64_t { return SNES::ppu.regs.window_mask[4]; },
495 [](uint64_t v) { SNES::ppu.regs.window_mask[4] = v; }},
496 {"ppu_window_mask[5]", []() -> uint64_t { return SNES::ppu.regs.window_mask[5]; },
497 [](uint64_t v) { SNES::ppu.regs.window_mask[5] = v; }},
498 {"ppu_color_mask", []() -> uint64_t { return SNES::ppu.regs.color_mask; },
499 [](uint64_t v) { SNES::ppu.regs.color_mask = v; }},
500 {"ppu_colorsub_mask", []() -> uint64_t { return SNES::ppu.regs.colorsub_mask; },
501 [](uint64_t v) { SNES::ppu.regs.colorsub_mask = v; }},
502 {"ppu_color_r", []() -> uint64_t { return SNES::ppu.regs.color_r; },
503 [](uint64_t v) { SNES::ppu.regs.color_r = v; }},
504 {"ppu_color_g", []() -> uint64_t { return SNES::ppu.regs.color_g; },
505 [](uint64_t v) { SNES::ppu.regs.color_g = v; }},
506 {"ppu_color_b", []() -> uint64_t { return SNES::ppu.regs.color_b; },
507 [](uint64_t v) { SNES::ppu.regs.color_b = v; }},
508 {"ppu_color_rgb", []() -> uint64_t { return SNES::ppu.regs.color_rgb; },
509 [](uint64_t v) { SNES::ppu.regs.color_rgb = v; }},
510 {"ppu_scanlines", []() -> uint64_t { return SNES::ppu.regs.scanlines; },
511 [](uint64_t v) { SNES::ppu.regs.scanlines = v; }},
512 {"ppu_hcounter", []() -> uint64_t { return SNES::ppu.regs.hcounter; },
513 [](uint64_t v) { SNES::ppu.regs.hcounter = v; }},
514 {"ppu_vcounter", []() -> uint64_t { return SNES::ppu.regs.vcounter; },
515 [](uint64_t v) { SNES::ppu.regs.vcounter = v; }},
516 {"ppu_vram_readbuffer", []() -> uint64_t { return SNES::ppu.regs.vram_readbuffer; },
517 [](uint64_t v) { SNES::ppu.regs.vram_readbuffer = v; }},
518 {"ppu_oam_itemcount", []() -> uint64_t { return SNES::ppu.regs.oam_itemcount; },
519 [](uint64_t v) { SNES::ppu.regs.oam_itemcount = v; }},
520 {"ppu_oam_tilecount", []() -> uint64_t { return SNES::ppu.regs.oam_tilecount; },
521 [](uint64_t v) { SNES::ppu.regs.oam_tilecount = v; }},
522 #endif
523 //TODO: SMP registers, DSP registers, chip registers.
524 {NULL, NULL, NULL}
525 };
526
527 #include "ports.inc"
528
529 core_region region_auto{{"autodetect", "Autodetect", 1, 0, true, {178683, 10738636}, {0,1,2}}};
530 core_region region_pal{{"pal", "PAL", 0, 2, false, {6448, 322445}, {2}}};
531 core_region region_ntsc{{"ntsc", "NTSC", 0, 1, false, {178683, 10738636}, {1}}};
532
533 std::vector<core_setting_value_param> boolean_values = {{"0", "False", 0}, {"1", "True", 1}};
534 core_setting_group bsnes_settings = {
535 {"port1", "Port 1 Type", "gamepad", {
536 {"none", "None", 0},
537 {"gamepad", "Gamepad", 1},
538 {"gamepad16", "Gamepad (16-button)", 2},
539 {"ygamepad16", "Y-cabled gamepad (16-button)", 9},
540 {"multitap", "Multitap", 3},
541 {"multitap16", "Multitap (16-button)", 4},
542 {"mouse", "Mouse", 5}
543 }},
544 {"port2", "Port 2 Type", "none", {
545 {"none", "None", 0},
546 {"gamepad", "Gamepad", 1},
547 {"gamepad16", "Gamepad (16-button)", 2},
548 {"ygamepad16", "Y-cabled gamepad (16-button)", 9},
549 {"multitap", "Multitap", 3},
550 {"multitap16", "Multitap (16-button)", 4},
551 {"mouse", "Mouse", 5},
552 {"superscope", "Super Scope", 8},
553 {"justifier", "Justifier", 6},
554 {"justifiers", "2 Justifiers", 7}
555 }},
556 {"hardreset", "Support hard resets", "0", boolean_values},
557 {"saveevery", "Emulate saving each frame", "0", boolean_values},
558 {"radominit", "Random initial state", "0", boolean_values},
559 {"compact", "Don't support delayed resets", "0", boolean_values},
560 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
561 {"alttimings", "Alternate poll timings", "0", boolean_values},
562 #endif
563 #ifdef BSNES_SUPPORTS_MOUSE_SPEED_FIX
564 {"mousespeed", "Support mouse speeds", "0", boolean_values},
565 #endif
566 };
567
568 ////////////////// PORTS COMMON ///////////////////
569 portctrl::type* index_to_ptype[] = {
570 &none, &gamepad, &gamepad16, &multitap, &multitap16, &mouse, &justifier, &justifiers, &superscope,
571 &ygamepad16
572 };
573 unsigned index_to_bsnes_type[] = {
574 SNES_DEVICE_NONE, SNES_DEVICE_JOYPAD, SNES_DEVICE_JOYPAD, SNES_DEVICE_MULTITAP, SNES_DEVICE_MULTITAP,
575 SNES_DEVICE_MOUSE, SNES_DEVICE_JUSTIFIER, SNES_DEVICE_JUSTIFIERS, SNES_DEVICE_SUPER_SCOPE,
576 SNES_DEVICE_JOYPAD
577 };
578
579 bool port_is_ycable[2];
580
581 void snesdbg_on_break();
582 void snesdbg_on_trace();
583 std::pair<int, uint64_t> recognize_address(uint64_t addr);
584
585 class my_interfaced : public SNES::Interface
586 {
587 string path(SNES::Cartridge::Slot slot, const string &hint)
588 {
589 return "./";
590 }
591 };
592
593 void basic_init()
594 {
595 static bool done = false;
596 if(done)
597 return;
598 done = true;
599 static my_interfaced i;
600 SNES::interface = &i;
601 }
602
603 core_type* internal_rom = NULL;
604
605 template<bool(*T)(const char*,const unsigned char*, unsigned)>
606 bool load_rom_X1(core_romimage* img)
607 {
608 return T(img[0].markup, img[0].data, img[0].size);
609 }
610
611 template<bool(*T)(const char*,const unsigned char*, unsigned, const char*,const unsigned char*, unsigned)>
612 bool load_rom_X2(core_romimage* img)
613 {
614 return T(img[0].markup, img[0].data, img[0].size,
615 img[1].markup, img[1].data, img[1].size);
616 }
617
618 template<bool(*T)(const char*,const unsigned char*, unsigned, const char*,const unsigned char*, unsigned,
619 const char*,const unsigned char*, unsigned)>
620 bool load_rom_X3(core_romimage* img)
621 {
622 return T(img[0].markup, img[0].data, img[0].size,
623 img[1].markup, img[1].data, img[1].size,
624 img[2].markup, img[2].data, img[2].size);
625 }
626
627
628 int load_rom(core_type* ctype, core_romimage* img, std::map<std::string, std::string>& settings,
629 uint64_t secs, uint64_t subsecs, bool(*fun)(core_romimage*))
630 {
631 std::map<std::string, std::string> _settings = settings;
632 bsnes_settings.fill_defaults(_settings);
633 signed type1 = bsnes_settings.ivalue_to_index(_settings, "port1");
634 signed type2 = bsnes_settings.ivalue_to_index(_settings, "port2");
635 signed hreset = bsnes_settings.ivalue_to_index(_settings, "hardreset");
636 signed compact = bsnes_settings.ivalue_to_index(_settings, "compact");
637 signed esave = bsnes_settings.ivalue_to_index(_settings, "saveevery");
638 signed irandom = bsnes_settings.ivalue_to_index(_settings, "radominit");
639 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
640 signed ialttimings = bsnes_settings.ivalue_to_index(_settings, "alttimings");
641 #endif
642 #ifdef BSNES_SUPPORTS_MOUSE_SPEED_FIX
643 signed ispeedfix = bsnes_settings.ivalue_to_index(_settings, "mousespeed");
644 #endif
645
646 basic_init();
647 snes_term();
648 snes_unload_cartridge();
649 SNES::config.random = (irandom != 0);
650 save_every_frame = (esave != 0);
651 support_hreset = (hreset != 0 || compact != 0);
652 support_dreset = (compact == 0);
653 SNES::config.expansion_port = SNES::System::ExpansionPortDevice::None;
654 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
655 SNES::config.cpu.alt_poll_timings = (ialttimings != 0);
656 #endif
657 #ifdef BSNES_SUPPORTS_MOUSE_SPEED_FIX
658 SNES::config.mouse_speed_fix = (ispeedfix != 0);
659 #endif
660 bool r = fun(img);
661 if(r) {
662 internal_rom = ctype;
663 snes_set_controller_port_device(false, index_to_bsnes_type[type1]);
664 snes_set_controller_port_device(true, index_to_bsnes_type[type2]);
665 port_is_ycable[0] = (type1 == 9);
666 port_is_ycable[1] = (type2 == 9);
667 have_saved_this_frame = false;
668 do_reset_flag = -1;
669 if(ecore_callbacks)
670 ecore_callbacks->action_state_updated();
671 }
672 return r ? 0 : -1;
673 }
674
675 controller_set bsnes_controllerconfig(std::map<std::string, std::string>& settings)
676 {
677 std::map<std::string, std::string> _settings = settings;
678 bsnes_settings.fill_defaults(_settings);
679 signed type1 = bsnes_settings.ivalue_to_index(_settings, "port1");
680 signed type2 = bsnes_settings.ivalue_to_index(_settings, "port2");
681 signed hreset = bsnes_settings.ivalue_to_index(_settings, "hardreset");
682 signed compact = bsnes_settings.ivalue_to_index(_settings, "compact");
683 controller_set r;
684 if(compact)
685 r.ports.push_back(&psystem_compact);
686 else if(hreset)
687 r.ports.push_back(&psystem_hreset);
688 else
689 r.ports.push_back(&psystem);
690 r.ports.push_back(index_to_ptype[type1]);
691 r.ports.push_back(index_to_ptype[type2]);
692 unsigned p1controllers = r.ports[1]->controller_info->controllers.size();
693 unsigned p2controllers = r.ports[2]->controller_info->controllers.size();
694 r.logical_map.resize(p1controllers + p2controllers);
695 if(p1controllers == 4) {
696 r.logical_map[0] = std::make_pair(1, 0);
697 for(size_t j = 0; j < p2controllers; j++)
698 r.logical_map[j + 1] = std::make_pair(2U, j);
699 for(size_t j = 1; j < p1controllers; j++)
700 r.logical_map[j + p2controllers] = std::make_pair(1U, j);
701 } else {
702 for(size_t j = 0; j < p1controllers; j++)
703 r.logical_map[j] = std::make_pair(1, j);
704 for(size_t j = 0; j < p2controllers; j++)
705 r.logical_map[j + p1controllers] = std::make_pair(2U, j);
706 }
707 return r;
708 }
709
710 class my_interface : public SNES::Interface
711 {
712 string path(SNES::Cartridge::Slot slot, const string &hint)
713 {
714 const char* _hint = hint;
715 std::string _hint2 = _hint;
716 std::string fwp = ecore_callbacks->get_firmware_path();
717 regex_results r;
718 std::string msubase = ecore_callbacks->get_base_path();
719 if(regex_match(".*\\.sfc", msubase))
720 msubase = msubase.substr(0, msubase.length() - 4);
721
722 if(_hint2 == "msu1.rom" || _hint2 == ".msu") {
723 //MSU-1 main ROM.
724 std::string x = msubase + ".msu";
725 messages << "MSU main data file: " << x << std::endl;
726 return x.c_str();
727 }
728 if(r = regex("(track)?(-([0-9]+)\\.pcm)", _hint2)) {
729 //MSU track.
730 std::string x = msubase + r[2];
731 messages << "MSU track " << r[3] << "': " << x << std::endl;
732 return x.c_str();
733 }
734 std::string finalpath = fwp + "/" + _hint2;
735 return finalpath.c_str();
736 }
737
738 time_t currentTime()
739 {
740 return ecore_callbacks->get_time();
741 }
742
743 time_t randomSeed()
744 {
745 return ecore_callbacks->get_randomseed();
746 }
747
748 void notifyLatched()
749 {
750 std::list<std::string> dummy;
751 ecore_callbacks->notify_latch(dummy);
752 }
753
754 void videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan);
755
756 void audioSample(int16_t l_sample, int16_t r_sample)
757 {
758 uint16_t _l = l_sample;
759 uint16_t _r = r_sample;
760 soundbuf[soundbuf_fill++] = l_sample;
761 soundbuf[soundbuf_fill++] = r_sample;
762 //The SMP emits a sample every 768 ticks of its clock. Use this in order to keep track of
763 //time.
764 ecore_callbacks->timer_tick(768, SNES::system.apu_frequency());
765 }
766
767 int16_t inputPoll(bool port, SNES::Input::Device device, unsigned index, unsigned id)
768 {
769 if(port_is_ycable[port ? 1 : 0]) {
770 int16_t bit0 = ecore_callbacks->get_input(port ? 2 : 1, 0, id);
771 int16_t bit1 = ecore_callbacks->get_input(port ? 2 : 1, 1, id);
772 return bit0 + 2 * bit1;
773 }
774 int16_t offset = 0;
775 //The superscope/justifier handling is nuts.
776 if(port && SNES::input.port2) {
777 SNES::SuperScope* ss = dynamic_cast<SNES::SuperScope*>(SNES::input.port2);
778 SNES::Justifier* js = dynamic_cast<SNES::Justifier*>(SNES::input.port2);
779 if(ss && index == 0) {
780 if(id == 0)
781 offset = ss->x;
782 if(id == 1)
783 offset = ss->y;
784 }
785 if(js && index == 0) {
786 if(id == 0)
787 offset = js->player1.x;
788 if(id == 1)
789 offset = js->player1.y;
790 }
791 if(js && js->chained && index == 1) {
792 if(id == 0)
793 offset = js->player2.x;
794 if(id == 1)
795 offset = js->player2.y;
796 }
797 }
798 return ecore_callbacks->get_input(port ? 2 : 1, index, id) - offset;
799 }
800 } my_interface_obj;
801
802 bool trace_fn()
803 {
804 #ifdef BSNES_HAS_DEBUGGER
805 if(trace_counter && !--trace_counter) {
806 //Trace counter did transition 1->0. Call the hook.
807 snesdbg_on_trace();
808 }
809 if(trace_cpu_enable) {
810 char buffer[1024];
811 SNES::cpu.disassemble_opcode(buffer, SNES::cpu.regs.pc);
812 ecore_callbacks->memory_trace(0, buffer, true);
813 }
814 return false;
815 #endif
816 }
817 bool smp_trace_fn()
818 {
819 #ifdef BSNES_HAS_DEBUGGER
820 if(trace_smp_enable) {
821 nall::string _disasm = SNES::smp.disassemble_opcode(SNES::smp.regs.pc);
822 std::string disasm(_disasm, _disasm.length());
823 ecore_callbacks->memory_trace(1, disasm.c_str(), true);
824 }
825 return false;
826 #endif
827 }
828 void sa1_trace_fn()
829 {
830 #ifdef BSNES_HAS_DEBUGGER
831 if(trace_sa1_enable) {
832 char buffer[1024];
833 SNES::sa1.disassemble_opcode(buffer, SNES::sa1.regs.pc);
834 ecore_callbacks->memory_trace(2, buffer, true);
835 }
836 #endif
837 }
838 void cpu_dma_fn(const char* buf)
839 {
840 if(trace_cpu_enable) {
841 ecore_callbacks->memory_trace(0, buf, false);
842 }
843 }
844 bool delayreset_fn()
845 {
846 trace_fn(); //Call this also.
847 if(delayreset_cycles_run == delayreset_cycles_target || video_refresh_done)
848 return true;
849 delayreset_cycles_run++;
850 return false;
851 }
852
853
854 bool trace_enabled()
855 {
856 return (trace_counter || !!trace_cpu_enable);
857 }
858
859 void update_trace_hook_state()
860 {
861 if(forced_hook)
862 return;
863 #ifdef BSNES_HAS_DEBUGGER
864 if(!trace_enabled())
865 SNES::cpu.step_event = nall::function<bool()>();
866 else
867 SNES::cpu.step_event = trace_fn;
868 if(!trace_smp_enable)
869 SNES::smp.step_event = nall::function<bool()>();
870 else
871 SNES::smp.step_event = smp_trace_fn;
872 #ifdef BSNES_SUPPORTS_TRACE_SA1
873 if(!trace_sa1_enable)
874 SNES::sa1.step_event = nall::function<void()>();
875 else
876 SNES::sa1.step_event = sa1_trace_fn;
877 SNES::sa1.trace_enabled = trace_sa1_enable;
878 #endif
879 #ifdef BSNES_SUPPORTS_DMA_TRACE
880 if(!trace_enabled())
881 SNES::cpu.dma_trace_fn = nall::function<void(const char*)>();
882 else
883 SNES::cpu.dma_trace_fn = cpu_dma_fn;
884 #endif
885 #endif
886 }
887
888 std::string sram_name(const nall::string& _id, SNES::Cartridge::Slot slotname)
889 {
890 std::string id(_id, _id.length());
891 //Fixup name change by bsnes v087...
892 if(id == "bsx.ram")
893 id = ".bss";
894 if(id == "bsx.psram")
895 id = ".bsp";
896 if(id == "program.rtc")
897 id = ".rtc";
898 if(id == "upd96050.ram")
899 id = ".dsp";
900 if(id == "program.ram")
901 id = ".srm";
902 if(slotname == SNES::Cartridge::Slot::SufamiTurboA)
903 return "slota." + id.substr(1);
904 if(slotname == SNES::Cartridge::Slot::SufamiTurboB)
905 return "slotb." + id.substr(1);
906 return id.substr(1);
907 }
908
909 uint8_t snes_bus_iospace_read(uint64_t offset)
910 {
911 disable_breakpoints = true;
912 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
913 uint8_t val = SNES::bus.read(offset, false);
914 #else
915 uint8_t val = SNES::bus.read(offset);
916 #endif
917 disable_breakpoints = false;
918 return val;
919 }
920
921 void snes_bus_iospace_write(uint64_t offset, uint8_t data)
922 {
923 disable_breakpoints = true;
924 SNES::bus.write(offset, data);
925 disable_breakpoints = false;
926 }
927
928 uint8_t ptrtable_iospace_read(uint64_t offset)
929 {
930 uint16_t entry = offset >> 4;
931 if(!ptrmap.count(entry))
932 return 0;
933 uint64_t val = ((offset & 15) < 8) ? ptrmap[entry].first : ptrmap[entry].second;
934 uint8_t byte = offset & 7;
935 //These things are always little-endian.
936 return (val >> (8 * byte));
937 }
938
939 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base, uint64_t size,
940 uint8_t (*readfn)(uint64_t offset), void (*writefn)(uint64_t offset, uint8_t data))
941 throw(std::bad_alloc)
942 {
943 if(size == 0)
944 return;
945 core_vma_info i;
946 i.name = name;
947 i.base = base;
948 i.size = size;
949 i.endian = -1;
950 i.special = true;
951 i.readonly = (writefn == NULL);
952 i.read = readfn;
953 i.write = writefn;
954 inf.push_back(i);
955 }
956
957 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base, uint8_t* memory,
958 uint64_t size, bool readonly, bool native_endian = false) throw(std::bad_alloc)
959 {
960 if(size == 0)
961 return;
962 core_vma_info i;
963 i.name = name;
964 i.base = base;
965 i.size = size;
966 i.backing_ram = memory;
967 i.readonly = readonly;
968 i.endian = native_endian ? 0 : -1;
969 i.volatile_flag = true;
970 //SRAMs aren't volatile.
971 for(unsigned j = 0; j < SNES::cartridge.nvram.size(); j++) {
972 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[j];
973 if(r.data == memory)
974 i.volatile_flag = false;
975 }
976 inf.push_back(i);
977 }
978
979 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base,
980 SNES::MappedRAM& memory, bool readonly, bool native_endian = false) throw(std::bad_alloc)
981 {
982 create_region(inf, name, base, memory.data(), memory.size(), readonly, native_endian);
983 }
984
985 void map_internal(std::list<core_vma_info>& inf, const std::string& name, uint16_t index, void* memory,
986 size_t memsize)
987 {
988 ptrmap[index] = std::make_pair(reinterpret_cast<uint64_t>(memory), static_cast<uint64_t>(memsize));
989 create_region(inf, name, 0x101000000 + index * 0x1000000, reinterpret_cast<uint8_t*>(memory),
990 memsize, true, true);
991 }
992
993 std::list<core_vma_info> get_VMAlist();
994 std::set<std::string> bsnes_srams()
995 {
996 std::set<std::string> r;
997 if(!internal_rom)
998 return r;
999 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
1000 SNES::Cartridge::NonVolatileRAM& s = SNES::cartridge.nvram[i];
1001 r.insert(sram_name(s.id, s.slot));
1002 }
1003 return r;
1004 }
1005
1006 uint64_t translate_class_address(uint8_t clazz, unsigned offset)
1007 {
1008 switch(clazz) {
1009 case 1: //ROM.
1010 return 0x80000000 + offset;
1011 case 2: //SRAM.
1012 return 0x10000000 + offset;
1013 case 3: //WRAM
1014 return 0x007E0000 + offset;
1015 case 6: //SA1IRAM
1016 return 0x00040000 + offset;
1017 case 8: //SufamiTurboA ROM.
1018 return 0x90000000 + offset;
1019 case 9: //SufamiTurboB ROM.
1020 return 0xA0000000 + offset;
1021 case 10: //SufamiTurboA RAM.
1022 return 0x20000000 + offset;
1023 case 11: //SufamiTurboB RAM.
1024 return 0x30000000 + offset;
1025 case 12: //BSX flash.
1026 return 0x90000000 + offset;
1027 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS_PPU
1028 #ifdef BSNES_IS_COMPAT
1029 case 13: //VRAM.
1030 return 0x00010000 + offset;
1031 case 14: //OAM.
1032 return 0x00020000 + offset;
1033 case 15: //GCRAM.
1034 return 0x00021000 + offset;
1035 #endif
1036 case 16: //APURAM
1037 return 0x00000000 + offset;
1038 #endif
1039 default: //Other, including bus.
1040 return 0xFFFFFFFFFFFFFFFFULL;
1041 }
1042 }
1043
1044 void bsnes_debug_read(uint8_t clazz, unsigned offset, unsigned addr, uint8_t val, bool exec)
1045 {
1046 if(disable_breakpoints) return;
1047 uint64_t _addr = translate_class_address(clazz, offset);
1048 if(_addr != 0xFFFFFFFFFFFFFFFFULL) {
1049 if(exec)
1050 ecore_callbacks->memory_execute(_addr, 0);
1051 else
1052 ecore_callbacks->memory_read(_addr, val);
1053 }
1054 if(exec)
1055 ecore_callbacks->memory_execute(0x1000000 + addr, 0);
1056 else
1057 ecore_callbacks->memory_read(0x1000000 + addr, val);
1058 }
1059
1060 void bsnes_debug_read2(uint8_t clazz, unsigned offset, uint8_t val, bool exec)
1061 {
1062 if(disable_breakpoints) return;
1063 uint64_t _addr = translate_class_address(clazz, offset);
1064 if(_addr != 0xFFFFFFFFFFFFFFFFULL) {
1065 //SMP uses this, so CPU#1.
1066 if(exec)
1067 ecore_callbacks->memory_execute(_addr, 1);
1068 else
1069 ecore_callbacks->memory_read(_addr, val);
1070 }
1071 }
1072
1073 void bsnes_debug_read3(uint8_t clazz, unsigned offset, uint8_t val)
1074 {
1075 if(disable_breakpoints) return;
1076 uint64_t _addr = translate_class_address(clazz, offset);
1077 if(_addr != 0xFFFFFFFFFFFFFFFFULL) {
1078 ecore_callbacks->memory_read(_addr, val);
1079 }
1080 }
1081
1082 void bsnes_debug_write(uint8_t clazz, unsigned offset, unsigned addr, uint8_t val)
1083 {
1084 if(disable_breakpoints) return;
1085 uint64_t _addr = translate_class_address(clazz, offset);
1086 if(_addr != 0xFFFFFFFFFFFFFFFFULL)
1087 ecore_callbacks->memory_write(_addr, val);
1088 ecore_callbacks->memory_write(0x1000000 + addr, val);
1089 }
1090
1091 void bsnes_debug_write2(uint8_t clazz, unsigned offset, uint8_t val)
1092 {
1093 if(disable_breakpoints) return;
1094 uint64_t _addr = translate_class_address(clazz, offset);
1095 if(_addr != 0xFFFFFFFFFFFFFFFFULL)
1096 ecore_callbacks->memory_write(_addr, val);
1097 }
1098
1099 void redraw_cover_fbinfo();
1100
1101 struct _bsnes_core : public core_core
1102 {
1103 _bsnes_core() : core_core({&gamepad, &gamepad16, &justifier, &justifiers, &mouse, &multitap,
1104 &multitap16, &none, &superscope, &psystem, &psystem_hreset, &psystem_compact}, {
1105 {0, "Soft reset", "reset", {}},
1106 {1, "Hard reset", "hardreset", {}},
1107 #ifdef BSNES_HAS_DEBUGGER
1108 {2, "Delayed soft reset", "delayreset", {
1109 {"Delay","int:0,99999999"}
1110 }},
1111 {3, "Delayed hard reset", "delayhardreset", {
1112 {"Delay","int:0,99999999"}
1113 }},
1114 #endif
1115 #ifdef BSNES_IS_COMPAT
1116 {4, "Layers‣BG1 Priority 0", "bg1pri0", {{"", "toggle"}}},
1117 {5, "Layers‣BG1 Priority 1", "bg1pri1", {{"", "toggle"}}},
1118 {8, "Layers‣BG2 Priority 0", "bg2pri0", {{"", "toggle"}}},
1119 {9, "Layers‣BG2 Priority 1", "bg2pri1", {{"", "toggle"}}},
1120 {12, "Layers‣BG3 Priority 0", "bg3pri0", {{"", "toggle"}}},
1121 {13, "Layers‣BG3 Priority 1", "bg3pri1", {{"", "toggle"}}},
1122 {16, "Layers‣BG4 Priority 0", "bg4pri0", {{"", "toggle"}}},
1123 {17, "Layers‣BG4 Priority 1", "bg4pri1", {{"", "toggle"}}},
1124 {20, "Layers‣Sprite Priority 0", "oampri0", {{"", "toggle"}}},
1125 {21, "Layers‣Sprite Priority 1", "oampri1", {{"", "toggle"}}},
1126 {22, "Layers‣Sprite Priority 2", "oampri2", {{"", "toggle"}}},
1127 {23, "Layers‣Sprite Priority 3", "oampri3", {{"", "toggle"}}},
1128 #endif
1129 }) {}
1130
1131 std::string c_core_identifier() const {
1132 return (stringfmt() << snes_library_id() << " (" << SNES::Info::Profile << " core)").str();
1133 }
1134 bool c_set_region(core_region& region) {
1135 if(&region == &region_auto)
1136 SNES::config.region = SNES::System::Region::Autodetect;
1137 else if(&region == &region_ntsc)
1138 SNES::config.region = SNES::System::Region::NTSC;
1139 else if(&region == &region_pal)
1140 SNES::config.region = SNES::System::Region::PAL;
1141 else
1142 return false;
1143 return true;
1144 }
1145 std::pair<uint32_t, uint32_t> c_video_rate() {
1146 if(!internal_rom)
1147 return std::make_pair(60, 1);
1148 uint32_t div;
1149 if(SNES::system.region() == SNES::System::Region::PAL)
1150 div = last_interlace ? DURATION_PAL_FIELD : DURATION_PAL_FRAME;
1151 else
1152 div = last_interlace ? DURATION_NTSC_FIELD : DURATION_NTSC_FRAME;
1153 return std::make_pair(SNES::system.cpu_frequency(), div);
1154 }
1155 double c_get_PAR() {
1156 double base = (SNES::system.region() == SNES::System::Region::PAL) ? 1.25 : 1.146;
1157 return base;
1158 }
1159 std::pair<uint32_t, uint32_t> c_audio_rate() {
1160 if(!internal_rom)
1161 return std::make_pair(64081, 2);
1162 return std::make_pair(SNES::system.apu_frequency(), static_cast<uint32_t>(768));
1163 }
1164 std::map<std::string, std::vector<char>> c_save_sram() throw(std::bad_alloc) {
1165 std::map<std::string, std::vector<char>> out;
1166 if(!internal_rom)
1167 return out;
1168 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
1169 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[i];
1170 std::string savename = sram_name(r.id, r.slot);
1171 std::vector<char> x;
1172 x.resize(r.size);
1173 memcpy(&x[0], r.data, r.size);
1174 out[savename] = x;
1175 }
1176 return out;
1177 }
1178 void c_load_sram(std::map<std::string, std::vector<char>>& sram) throw(std::bad_alloc) {
1179 std::set<std::string> used;
1180 if(!internal_rom) {
1181 for(auto i : sram)
1182 messages << "WARNING: SRAM '" << i.first << ": Not found on cartridge."
1183 << std::endl;
1184 return;
1185 }
1186 if(sram.empty())
1187 return;
1188 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
1189 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[i];
1190 std::string savename = sram_name(r.id, r.slot);
1191 if(sram.count(savename)) {
1192 std::vector<char>& x = sram[savename];
1193 if(r.size != x.size())
1194 messages << "WARNING: SRAM '" << savename << "': Loaded " << x.size()
1195 << " bytes, but the SRAM is " << r.size << "." << std::endl;
1196 memcpy(r.data, &x[0], (r.size < x.size()) ? r.size : x.size());
1197 used.insert(savename);
1198 } else
1199 messages << "WARNING: SRAM '" << savename << ": No data." << std::endl;
1200 }
1201 for(auto i : sram)
1202 if(!used.count(i.first))
1203 messages << "WARNING: SRAM '" << i.first << ": Not found on cartridge."
1204 << std::endl;
1205 }
1206 void c_serialize(std::vector<char>& out) {
1207 if(!internal_rom)
1208 throw std::runtime_error("No ROM loaded");
1209 serializer s = SNES::system.serialize();
1210 out.resize(s.size());
1211 memcpy(&out[0], s.data(), s.size());
1212 }
1213 void c_unserialize(const char* in, size_t insize) {
1214 if(!internal_rom)
1215 throw std::runtime_error("No ROM loaded");
1216 serializer s(reinterpret_cast<const uint8_t*>(in), insize);
1217 if(!SNES::system.unserialize(s))
1218 throw std::runtime_error("SNES core rejected savestate");
1219 have_saved_this_frame = true;
1220 do_reset_flag = -1;
1221 }
1222 core_region& c_get_region() {
1223 return (SNES::system.region() == SNES::System::Region::PAL) ? region_pal : region_ntsc;
1224 }
1225 void c_power() {
1226 if(internal_rom) snes_power();
1227 }
1228 void c_unload_cartridge() {
1229 if(!internal_rom) return;
1230 snes_term();
1231 snes_unload_cartridge();
1232 internal_rom = NULL;
1233 }
1234 std::pair<uint32_t, uint32_t> c_get_scale_factors(uint32_t width, uint32_t height) {
1235 return std::make_pair((width < 400) ? 2 : 1, (height < 400) ? 2 : 1);
1236 }
1237 void c_install_handler() {
1238 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1239 SNES::bus.debug_read = bsnes_debug_read;
1240 SNES::bus.debug_write = bsnes_debug_write;
1241 #endif
1242 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS_PPU
1243 #ifdef BSNES_IS_COMPAT
1244 SNES::ppu.debug_read = bsnes_debug_read3;
1245 SNES::ppu.debug_write = bsnes_debug_write2;
1246 #endif
1247 SNES::smp.debug_read = bsnes_debug_read2;
1248 SNES::smp.debug_write = bsnes_debug_write2;
1249 #endif
1250 basic_init();
1251 old = SNES::interface;
1252 SNES::interface = &my_interface_obj;
1253 SNES::system.init();
1254 magic_flags |= 1;
1255 }
1256 void c_uninstall_handler() { SNES::interface = old; }
1257 void c_emulate() {
1258 if(!internal_rom)
1259 return;
1260 bool was_delay_reset = false;
1261 int16_t reset = ecore_callbacks->get_input(0, 0, 1);
1262 int16_t hreset = 0;
1263 if(support_hreset)
1264 hreset = ecore_callbacks->get_input(0, 0, 4);
1265 if(reset) {
1266 long hi = ecore_callbacks->get_input(0, 0, 2);
1267 long lo = ecore_callbacks->get_input(0, 0, 3);
1268 long delay = 10000 * hi + lo;
1269 if(delay > 0) {
1270 was_delay_reset = true;
1271 #ifdef BSNES_HAS_DEBUGGER
1272 messages << "Executing delayed reset... This can take some time!"
1273 << std::endl;
1274 video_refresh_done = false;
1275 delayreset_cycles_run = 0;
1276 delayreset_cycles_target = delay;
1277 forced_hook = true;
1278 SNES::cpu.step_event = delayreset_fn;
1279 again:
1280 SNES::system.run();
1281 if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent
1282 && SNES::debugger.break_event ==
1283 SNES::Debugger::BreakEvent::BreakpointHit) {
1284 snesdbg_on_break();
1285 goto again;
1286 }
1287 SNES::cpu.step_event = nall::function<bool()>();
1288 forced_hook = false;
1289 update_trace_hook_state();
1290 if(video_refresh_done) {
1291 //Force the reset here.
1292 do_reset_flag = -1;
1293 messages << "SNES reset (forced at " << delayreset_cycles_run << ")"
1294 << std::endl;
1295 if(hreset)
1296 SNES::system.power();
1297 else
1298 SNES::system.reset();
1299 return;
1300 }
1301 if(hreset)
1302 SNES::system.power();
1303 else
1304 SNES::system.reset();
1305 messages << "SNES reset (delayed " << delayreset_cycles_run << ")"
1306 << std::endl;
1307 #else
1308 messages << "Delayresets not supported on this bsnes version "
1309 "(needs v084 or v085)" << std::endl;
1310 if(hreset)
1311 SNES::system.power();
1312 else
1313 SNES::system.reset();
1314 #endif
1315 } else if(delay == 0) {
1316 if(hreset)
1317 SNES::system.power();
1318 else
1319 SNES::system.reset();
1320 messages << "SNES reset" << std::endl;
1321 }
1322 }
1323 do_reset_flag = -1;
1324
1325 if(!have_saved_this_frame && save_every_frame && !was_delay_reset)
1326 SNES::system.runtosave();
1327 #ifdef BSNES_HAS_DEBUGGER
1328 if(trace_enabled())
1329 SNES::cpu.step_event = trace_fn;
1330 #endif
1331 again2:
1332 SNES::system.run();
1333 #ifdef BSNES_HAS_DEBUGGER
1334 if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent &&
1335 SNES::debugger.break_event == SNES::Debugger::BreakEvent::BreakpointHit) {
1336 snesdbg_on_break();
1337 goto again2;
1338 }
1339 SNES::cpu.step_event = nall::function<bool()>();
1340 #endif
1341 have_saved_this_frame = false;
1342 }
1343 void c_runtosave() {
1344 if(!internal_rom)
1345 return;
1346 stepping_into_save = true;
1347 SNES::system.runtosave();
1348 have_saved_this_frame = true;
1349 stepping_into_save = false;
1350 }
1351 bool c_get_pflag() { return SNES::cpu.controller_flag; }
1352 void c_set_pflag(bool pflag) { SNES::cpu.controller_flag = pflag; }
1353 framebuffer::raw& c_draw_cover() {
1354 static framebuffer::raw x(cover_fbinfo);
1355 redraw_cover_fbinfo();
1356 return x;
1357 }
1358 std::string c_get_core_shortname() const
1359 {
1360 #ifdef BSNES_IS_COMPAT
1361 return (stringfmt() << "bsnes" << BSNES_VERSION << "c").str();
1362 #else
1363 return (stringfmt() << "bsnes" << BSNES_VERSION << "a").str();
1364 #endif
1365 }
1366 void c_pre_emulate_frame(portctrl::frame& cf)
1367 {
1368 cf.axis3(0, 0, 1, (do_reset_flag >= 0) ? 1 : 0);
1369 if(support_hreset)
1370 cf.axis3(0, 0, 4, do_hreset_flag ? 1 : 0);
1371 if(do_reset_flag >= 0) {
1372 cf.axis3(0, 0, 2, do_reset_flag / 10000);
1373 cf.axis3(0, 0, 3, do_reset_flag % 10000);
1374 } else {
1375 cf.axis3(0, 0, 2, 0);
1376 cf.axis3(0, 0, 3, 0);
1377 }
1378 }
1379 void c_execute_action(unsigned id, const std::vector<interface_action_paramval>& p)
1380 {
1381 switch(id) {
1382 case 0: //Soft reset.
1383 do_reset_flag = 0;
1384 do_hreset_flag = false;
1385 break;
1386 case 1: //Hard reset.
1387 do_reset_flag = 0;
1388 do_hreset_flag = true;
1389 break;
1390 case 2: //Delayed soft reset.
1391 do_reset_flag = p[0].i;
1392 do_hreset_flag = false;
1393 break;
1394 case 3: //Delayed hard reset.
1395 do_reset_flag = p[0].i;
1396 do_hreset_flag = true;
1397 break;
1398 }
1399 #ifdef BSNES_IS_COMPAT
1400 if(id >= 4 && id <= 23) {
1401 unsigned y = (id - 4) / 4;
1402 SNES::ppu.layer_enabled[y][id % 4] = !SNES::ppu.layer_enabled[y][id % 4];
1403 ecore_callbacks->action_state_updated();
1404 }
1405 #endif
1406 }
1407 const interface_device_reg* c_get_registers() { return snes_registers; }
1408 unsigned c_action_flags(unsigned id)
1409 {
1410 if((id == 2 || id == 3) && !support_dreset)
1411 return 0;
1412 if(id == 0 || id == 2)
1413 return 1;
1414 if(id == 1 || id == 3)
1415 return support_hreset ? 1 : 0;
1416 #ifdef BSNES_IS_COMPAT
1417 if(id >= 4 && id <= 23) {
1418 unsigned y = (id - 4) / 4;
1419 return SNES::ppu.layer_enabled[y][id % 4] ? 3 : 1;
1420 }
1421 #endif
1422 return 0; //WTF?
1423 }
1424 int c_reset_action(bool hard)
1425 {
1426 return hard ? (support_hreset ? 1 : -1) : 0;
1427 }
1428 std::pair<uint64_t, uint64_t> c_get_bus_map()
1429 {
1430 return std::make_pair(0x1000000, 0x1000000);
1431 }
1432 std::list<core_vma_info> c_vma_list() { return get_VMAlist(); }
1433 std::set<std::string> c_srams() { return bsnes_srams(); }
1434 std::pair<unsigned, unsigned> c_lightgun_scale() {
1435 return std::make_pair(256, last_PAL ? 239 : 224);
1436 }
1437 void c_set_debug_flags(uint64_t addr, unsigned int sflags, unsigned int cflags)
1438 {
1439 if(addr == 0) {
1440 if(sflags & 8) trace_cpu_enable = true;
1441 if(cflags & 8) trace_cpu_enable = false;
1442 update_trace_hook_state();
1443 }
1444 if(addr == 1) {
1445 if(sflags & 8) trace_smp_enable = true;
1446 if(cflags & 8) trace_smp_enable = false;
1447 update_trace_hook_state();
1448 }
1449 if(addr == 2) {
1450 if(sflags & 8) trace_sa1_enable = true;
1451 if(cflags & 8) trace_sa1_enable = false;
1452 update_trace_hook_state();
1453 }
1454 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1455 auto _addr = recognize_address(addr);
1456 if(_addr.first == ADDR_KIND_ALL)
1457 SNES::bus.debugFlags(sflags & 7, cflags & 7);
1458 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS_PPU
1459 #ifdef BSNES_IS_COMPAT
1460 else if(_addr.first == 13) //VRAM.
1461 SNES::ppu.vram_debugflags[_addr.second] =
1462 SNES::ppu.vram_debugflags[_addr.second] & ~(cflags & 7) | (sflags & 7);
1463 else if(_addr.first == 14) //OAM.
1464 SNES::ppu.oam_debugflags[_addr.second] =
1465 SNES::ppu.oam_debugflags[_addr.second] & ~(cflags & 7) | (sflags & 7);
1466 else if(_addr.first == 15) //CGRAM.
1467 SNES::ppu.cgram_debugflags[_addr.second] =
1468 SNES::ppu.cgram_debugflags[_addr.second] & ~(cflags & 7) | (sflags & 7);
1469 #endif
1470 else if(_addr.first == 16) //APURAM.
1471 SNES::smp.debugflags[_addr.second] =
1472 SNES::smp.debugflags[_addr.second] & ~(cflags & 7) | (sflags & 7);
1473 #endif
1474 else if(_addr.first != ADDR_KIND_NONE && ((sflags | cflags) & 7))
1475 SNES::bus.debugFlags(sflags & 7, cflags & 7, _addr.first, _addr.second);
1476 #endif
1477 }
1478 void c_set_cheat(uint64_t addr, uint64_t value, bool set)
1479 {
1480 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1481 bool s = false;
1482 auto _addr = recognize_address(addr);
1483 //13-16 are VRAM, OAM, CGRAM and APURAM, can't cheat on those (yet).
1484 if(_addr.first == ADDR_KIND_NONE || _addr.first == ADDR_KIND_ALL ||
1485 (_addr.first >= 13 && _addr.first <= 16))
1486 return;
1487 unsigned x = 0;
1488 while(x < 0x1000000) {
1489 x = SNES::bus.enumerateMirrors(_addr.first, _addr.second, x);
1490 if(x < 0x1000000) {
1491 if(set) {
1492 for(size_t i = 0; i < SNES::cheat.size(); i++) {
1493 if(SNES::cheat[i].addr == x) {
1494 SNES::cheat[i].data = value;
1495 s = true;
1496 break;
1497 }
1498 }
1499 if(!s) SNES::cheat.append({x, (uint8_t)value, true});
1500 } else
1501 for(size_t i = 0; i < SNES::cheat.size(); i++) {
1502 if(SNES::cheat[i].addr == x) {
1503 SNES::cheat.remove(i);
1504 break;
1505 }
1506 }
1507 }
1508 x++;
1509 }
1510 SNES::cheat.synchronize();
1511 #endif
1512 }
1513 void c_debug_reset()
1514 {
1515 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1516 SNES::bus.clearDebugFlags();
1517 SNES::cheat.reset();
1518 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS_PPU
1519 #ifdef BSNES_IS_COMPAT
1520 memset(SNES::ppu.vram_debugflags, 0, sizeof(SNES::ppu.vram_debugflags));
1521 memset(SNES::ppu.oam_debugflags, 0, sizeof(SNES::ppu.oam_debugflags));
1522 memset(SNES::ppu.cgram_debugflags, 0, sizeof(SNES::ppu.cgram_debugflags));
1523 #endif
1524 memset(SNES::smp.debugflags, 0, sizeof(SNES::smp.debugflags));
1525 #endif
1526 #endif
1527 trace_cpu_enable = false;
1528 trace_smp_enable = false;
1529 update_trace_hook_state();
1530 }
1531 std::vector<std::string> c_get_trace_cpus()
1532 {
1533 std::vector<std::string> r;
1534 r.push_back("cpu");
1535 r.push_back("smp");
1536 #ifdef BSNES_SUPPORTS_TRACE_SA1
1537 r.push_back("sa1");
1538 #endif
1539 //TODO: Trace various chips.
1540 return r;
1541 }
1542 } bsnes_core;
1543
1544 struct _type_snes : public core_type
1545 {
1546 _type_snes()
1547 : core_type({{
1548 .iname = "snes",
1549 .hname = "SNES",
1550 .id = 0,
1551 .sysname = "SNES",
1552 .bios = NULL,
1553 .regions = {&region_auto, &region_ntsc, &region_pal},
1554 .images = {{"rom", "Cartridge ROM", 1, 0, 512,
1555 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"}},
1556 .settings = bsnes_settings,
1557 .core = &bsnes_core,
1558 }}) {}
1559
1560 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1561 uint64_t secs, uint64_t subsecs)
1562 {
1563 return load_rom(this, img, settings, secs, subsecs,
1564 load_rom_X1<snes_load_cartridge_normal>);
1565 }
1566 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1567 {
1568 return bsnes_controllerconfig(settings);
1569 }
1570 } type_snes;
1571 core_sysregion snes_pal("snes_pal", type_snes, region_pal);
1572 core_sysregion snes_ntsc("snes_ntsc", type_snes, region_ntsc);
1573
1574 struct _type_bsx : public core_type, public core_sysregion
1575 {
1576 _type_bsx()
1577 : core_type({{
1578 .iname = "bsx",
1579 .hname = "BS-X (non-slotted)",
1580 .id = 1,
1581 .sysname = "BS-X",
1582 .bios = "bsx.sfc",
1583 .regions = {&region_ntsc},
1584 .images = {{"rom", "BS-X BIOS", 1, 0, 512,
1585 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1586 {"bsx", "BS-X Flash", 2, 0, 512, "bs"}},
1587 .settings = bsnes_settings,
1588 .core = &bsnes_core,
1589 }}),
1590 core_sysregion("bsx", *this, region_ntsc) {}
1591
1592 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1593 uint64_t secs, uint64_t subsecs)
1594 {
1595 return load_rom(this, img, settings, secs, subsecs,
1596 load_rom_X2<snes_load_cartridge_bsx>);
1597 }
1598 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1599 {
1600 return bsnes_controllerconfig(settings);
1601 }
1602 } type_bsx;
1603
1604 struct _type_bsxslotted : public core_type, public core_sysregion
1605 {
1606 _type_bsxslotted()
1607 : core_type({{
1608 .iname = "bsxslotted",
1609 .hname = "BS-X (slotted)",
1610 .id = 2,
1611 .sysname = "BS-X",
1612 .bios = "bsxslotted.sfc",
1613 .regions = {&region_ntsc},
1614 .images = {{"rom", "BS-X BIOS", 1, 0, 512,
1615 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1616 {"bsx", "BS-X Flash", 2, 0, 512, "bss"}},
1617 .settings = bsnes_settings,
1618 .core = &bsnes_core,
1619 }}),
1620 core_sysregion("bsxslotted", *this, region_ntsc) {}
1621 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1622 uint64_t secs, uint64_t subsecs)
1623 {
1624 return load_rom(this, img, settings, secs, subsecs,
1625 load_rom_X2<snes_load_cartridge_bsx_slotted>);
1626 }
1627 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1628 {
1629 return bsnes_controllerconfig(settings);
1630 }
1631 } type_bsxslotted;
1632
1633 struct _type_sufamiturbo : public core_type, public core_sysregion
1634 {
1635 _type_sufamiturbo()
1636 : core_type({{
1637 .iname = "sufamiturbo",
1638 .hname = "Sufami Turbo",
1639 .id = 3,
1640 .sysname = "SufamiTurbo",
1641 .bios = "sufamiturbo.sfc",
1642 .regions = {&region_ntsc},
1643 .images = {
1644 {"rom", "ST BIOS", 1, 0, 512, "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1645 {"slot-a", "ST SLOT A ROM", 2, 0, 512, "st"},
1646 {"slot-b", "ST SLOT B ROM", 2, 0, 512, "st"}
1647 },
1648 .settings = bsnes_settings,
1649 .core = &bsnes_core,
1650 }}),
1651 core_sysregion("sufamiturbo", *this, region_ntsc) {}
1652 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1653 uint64_t secs, uint64_t subsecs)
1654 {
1655 return load_rom(this, img, settings, secs, subsecs,
1656 load_rom_X3<snes_load_cartridge_sufami_turbo>);
1657 }
1658 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1659 {
1660 return bsnes_controllerconfig(settings);
1661 }
1662 } type_sufamiturbo;
1663
1664 struct _type_sgb : public core_type
1665 {
1666 _type_sgb()
1667 : core_type({{
1668 .iname = "sgb",
1669 .hname = "Super Game Boy",
1670 .id = 4,
1671 .sysname = "SGB",
1672 .bios = "sgb.sfc",
1673 .regions = {&region_auto, &region_ntsc, &region_pal},
1674 .images = {{"rom", "SGB BIOS", 1, 0, 512,
1675 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1676 {"dmg", "DMG ROM", 2, 0, 512, "gb;dmg;sgb"}},
1677 .settings = bsnes_settings,
1678 .core = &bsnes_core,
1679 }}) {}
1680 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1681 uint64_t secs, uint64_t subsecs)
1682 {
1683 return load_rom(this, img, settings, secs, subsecs,
1684 load_rom_X2<snes_load_cartridge_super_game_boy>);
1685 }
1686 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1687 {
1688 return bsnes_controllerconfig(settings);
1689 }
1690 } type_sgb;
1691 core_sysregion sgb_pal("sgb_pal", type_sgb, region_pal);
1692 core_sysregion sgb_ntsc("sgb_ntsc", type_sgb, region_ntsc);
1693
1694 void redraw_cover_fbinfo()
1695 {
1696 for(size_t i = 0; i < sizeof(cover_fbmem) / sizeof(cover_fbmem[0]); i++)
1697 cover_fbmem[i] = 0;
1698 std::string ident = bsnes_core.get_core_identifier();
1699 cover_render_string(cover_fbmem, 0, 0, ident, 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1700 std::ostringstream name;
1701 name << "Internal ROM name: ";
1702 disable_breakpoints = true;
1703 for(unsigned i = 0; i < 21; i++) {
1704 unsigned busaddr = 0x00FFC0 + i;
1705 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1706 unsigned char ch = SNES::bus.read(busaddr, false);
1707 #else
1708 unsigned char ch = SNES::bus.read(busaddr);
1709 #endif
1710 if(ch < 32 || ch > 126)
1711 name << "<" << hex::to8(ch) << ">";
1712 else
1713 name << ch;
1714 }
1715 disable_breakpoints = false;
1716 cover_render_string(cover_fbmem, 0, 16, name.str(), 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1717 unsigned y = 32;
1718 for(auto i : cover_information()) {
1719 cover_render_string(cover_fbmem, 0, y, i, 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1720 y += 16;
1721 }
1722 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
1723 if(SNES::config.cpu.alt_poll_timings) {
1724 cover_render_string(cover_fbmem, 0, y, "Alternate timings enabled.", 0x7FFFF, 0x00000,
1725 512, 448, 2048, 4);
1726 y += 16;
1727 }
1728 #endif
1729 #ifdef BSNES_SUPPORTS_MOUSE_SPEED_FIX
1730 if(SNES::config.mouse_speed_fix) {
1731 cover_render_string(cover_fbmem, 0, y, "Mouse speed support enabled.", 0x7FFFF, 0x00000,
1732 512, 448, 2048, 4);
1733 y += 16;
1734 }
1735 #endif
1736 }
1737
1738 void my_interface::videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan)
1739 {
1740 last_hires = hires;
1741 last_interlace = interlace;
1742 bool region = (SNES::system.region() == SNES::System::Region::PAL);
1743 last_PAL = region;
1744 if(stepping_into_save)
1745 messages << "Got video refresh in runtosave, expect desyncs!" << std::endl;
1746 video_refresh_done = true;
1747 uint32_t fps_n, fps_d;
1748 auto fps = bsnes_core.get_video_rate();
1749 fps_n = fps.first;
1750 fps_d = fps.second;
1751 uint32_t g = gcd(fps_n, fps_d);
1752 fps_n /= g;
1753 fps_d /= g;
1754
1755 framebuffer::info inf;
1756 inf.type = &framebuffer::pixfmt_lrgb;
1757 inf.mem = const_cast<char*>(reinterpret_cast<const char*>(data));
1758 inf.physwidth = 512;
1759 inf.physheight = 512;
1760 inf.physstride = 2048;
1761 inf.width = hires ? 512 : 256;
1762 inf.height = (region ? 239 : 224) * (interlace ? 2 : 1);
1763 inf.stride = interlace ? 2048 : 4096;
1764 inf.offset_x = 0;
1765 inf.offset_y = (region ? (overscan ? 9 : 1) : (overscan ? 16 : 9)) * 2;
1766 framebuffer::raw ls(inf);
1767
1768 ecore_callbacks->output_frame(ls, fps_n, fps_d);
1769 if(soundbuf_fill > 0) {
1770 auto freq = SNES::system.apu_frequency();
1771 CORE().audio->submit_buffer(soundbuf, soundbuf_fill / 2, true, freq / 768.0);
1772 soundbuf_fill = 0;
1773 }
1774 }
1775
1776 std::list<core_vma_info> get_VMAlist()
1777 {
1778 std::list<core_vma_info> ret;
1779 if(!internal_rom)
1780 return ret;
1781 create_region(ret, "WRAM", 0x007E0000, SNES::cpu.wram, 131072, false);
1782 create_region(ret, "APURAM", 0x00000000, SNES::smp.apuram, 65536, false);
1783 create_region(ret, "VRAM", 0x00010000, SNES::ppu.vram, 65536, false);
1784 create_region(ret, "OAM", 0x00020000, SNES::ppu.oam, 544, false);
1785 create_region(ret, "CGRAM", 0x00021000, SNES::ppu.cgram, 512, false);
1786 if(SNES::cartridge.has_srtc()) create_region(ret, "RTC", 0x00022000, SNES::srtc.rtc, 20, false);
1787 if(SNES::cartridge.has_spc7110rtc()) create_region(ret, "RTC", 0x00022000, SNES::spc7110.rtc, 20,
1788 false);
1789 if(SNES::cartridge.has_necdsp()) {
1790 create_region(ret, "DSPRAM", 0x00023000, reinterpret_cast<uint8_t*>(SNES::necdsp.dataRAM),
1791 4096, false, true);
1792 create_region(ret, "DSPPROM", 0xF0000000, reinterpret_cast<uint8_t*>(SNES::necdsp.programROM),
1793 65536, true, true);
1794 create_region(ret, "DSPDROM", 0xF0010000, reinterpret_cast<uint8_t*>(SNES::necdsp.dataROM),
1795 4096, true, true);
1796 }
1797 if(SNES::cartridge.has_sa1())
1798 create_region(ret, "SA1IRAM", 0x00040000, SNES::sa1.iram.data(), SNES::sa1.iram.size(),
1799 false);
1800 create_region(ret, "SRAM", 0x10000000, SNES::cartridge.ram, false);
1801 create_region(ret, "ROM", 0x80000000, SNES::cartridge.rom, true);
1802 create_region(ret, "BUS", 0x1000000, 0x1000000, snes_bus_iospace_read, snes_bus_iospace_write);
1803 create_region(ret, "PTRTABLE", 0x100000000, 0x100000, ptrtable_iospace_read, NULL);
1804 map_internal(ret, "CPU_STATE", 0, &SNES::cpu, sizeof(SNES::cpu));
1805 map_internal(ret, "PPU_STATE", 1, &SNES::ppu, sizeof(SNES::ppu));
1806 map_internal(ret, "SMP_STATE", 2, &SNES::smp, sizeof(SNES::smp));
1807 map_internal(ret, "DSP_STATE", 3, &SNES::dsp, sizeof(SNES::dsp));
1808 if(internal_rom == &type_bsx || internal_rom == &type_bsxslotted) {
1809 create_region(ret, "BSXFLASH", 0x90000000, SNES::bsxflash.memory, true);
1810 create_region(ret, "BSX_RAM", 0x20000000, SNES::bsxcartridge.sram, false);
1811 create_region(ret, "BSX_PRAM", 0x30000000, SNES::bsxcartridge.psram, false);
1812 }
1813 if(internal_rom == &type_sufamiturbo) {
1814 create_region(ret, "SLOTA_ROM", 0x90000000, SNES::sufamiturbo.slotA.rom, true);
1815 create_region(ret, "SLOTB_ROM", 0xA0000000, SNES::sufamiturbo.slotB.rom, true);
1816 create_region(ret, "SLOTA_RAM", 0x20000000, SNES::sufamiturbo.slotA.ram, false);
1817 create_region(ret, "SLOTB_RAM", 0x30000000, SNES::sufamiturbo.slotB.ram, false);
1818 }
1819 if(internal_rom == &type_sgb) {
1820 map_internal(ret, "GBCPU_STATE", 4, &GameBoy::cpu, sizeof(GameBoy::cpu));
1821 create_region(ret, "GBROM", 0x90000000, GameBoy::cartridge.romdata,
1822 GameBoy::cartridge.romsize, true);
1823 create_region(ret, "GBRAM", 0x20000000, GameBoy::cartridge.ramdata,
1824 GameBoy::cartridge.ramsize, false);
1825 create_region(ret, "GBWRAM", 0x00030000, GameBoy::cpu.wram, 32768, false);
1826 create_region(ret, "GBHRAM", 0x00038000, GameBoy::cpu.hram, 128, true);
1827 }
1828 return ret;
1829 }
1830
1831 std::pair<int, uint64_t> recognize_address(uint64_t addr)
1832 {
1833 if(addr == 0xFFFFFFFFFFFFFFFFULL)
1834 return std::make_pair(ADDR_KIND_ALL, 0);
1835 if(addr >= 0x80000000 && addr <= 0x8FFFFFFF) //Rom.
1836 return std::make_pair(1, addr - 0x80000000);
1837 if(addr >= 0x10000000 && addr <= 0x1FFFFFFF) //SRAM.
1838 return std::make_pair(2, addr - 0x10000000);
1839 if(addr >= 0x007E0000 && addr <= 0x007FFFFF) //WRAM.
1840 return std::make_pair(3, addr - 0x007E0000);
1841 if(addr >= 0x00040000 && addr <= 0x000407FF) //SA1IRAM.
1842 return std::make_pair(6, addr - 0x00040000);
1843 if(addr >= 0x00010000 && addr <= 0x00020000) //VRAM.
1844 return std::make_pair(13, addr - 0x00010000);
1845 if(addr >= 0x00020000 && addr <= 0x0002021F) //OAM.
1846 return std::make_pair(14, addr - 0x00020000);
1847 if(addr >= 0x00021000 && addr <= 0x000211FF) //CGRAM.
1848 return std::make_pair(15, addr - 0x00021000);
1849 if(addr >= 0x00000000 && addr <= 0x0000FFFF) //APURAM.
1850 return std::make_pair(16, addr - 0x00000000);
1851 if(internal_rom == &type_sufamiturbo) {
1852 if(addr >= 0x90000000 && addr <= 0x9FFFFFFF) //SufamiTurboA Rom.
1853 return std::make_pair(8, addr - 0x90000000);
1854 if(addr >= 0xA0000000 && addr <= 0xAFFFFFFF) //SufamiTurboB Rom.
1855 return std::make_pair(9, addr - 0x90000000);
1856 if(addr >= 0x20000000 && addr <= 0x2FFFFFFF) //SufamiTurboA Ram.
1857 return std::make_pair(10, addr - 0x20000000);
1858 if(addr >= 0x20000000 && addr <= 0x3FFFFFFF) //SufamiTurboB Ram.
1859 return std::make_pair(11, addr - 0x30000000);
1860 }
1861 if(internal_rom == &type_bsx || internal_rom == &type_bsxslotted) {
1862 if(addr >= 0x90000000 && addr <= 0x9FFFFFFF) //BSX flash.
1863 return std::make_pair(12, addr - 0x90000000);
1864 }
1865 if(addr >= 0x01000000 && addr <= 0x01FFFFFF) //BUS.
1866 return std::make_pair(255, addr - 0x01000000);
1867 return std::make_pair(ADDR_KIND_NONE, 0);
1868 }
1869
1870 command::fnptr<command::arg_filename> dump_core(lsnes_cmds, "dump-core", "No description available",
1871 "No description available\n",
1872 [](command::arg_filename args) throw(std::bad_alloc, std::runtime_error) {
1873 std::vector<char> out;
1874 bsnes_core.serialize(out);
1875 std::ofstream x(args, std::ios_base::out | std::ios_base::binary);
1876 x.write(&out[0], out.size());
1877 });
1878
1879 #ifdef BSNES_HAS_DEBUGGER
1880 lua::state* snes_debug_cb_keys[SNES::Debugger::Breakpoints];
1881 lua::state* snes_debug_cb_trace;
1882
1883 void snesdbg_execute_callback(lua::state*& cb, signed r)
1884 {
1885 auto& core = CORE();
1886 if(!cb)
1887 return;
1888 cb->pushlightuserdata(&cb);
1889 cb->gettable(LUA_REGISTRYINDEX);
1890 cb->pushnumber(r);
1891 if(cb->type(-2) == LUA_TFUNCTION) {
1892 int s = cb->pcall(1, 0, 0);
1893 if(s)
1894 cb->pop(1);
1895 } else {
1896 messages << "Can't execute debug callback" << std::endl;
1897 cb->pop(2);
1898 }
1899 if(core.lua2->requests_repaint) {
1900 core.lua2->requests_repaint = false;
1901 core.command->invoke("repaint");
1902 }
1903 }
1904
1905 void snesdbg_on_break()
1906 {
1907 signed r = SNES::debugger.breakpoint_hit;
1908 snesdbg_execute_callback(snes_debug_cb_keys[r], r);
1909 }
1910
1911 void snesdbg_on_trace()
1912 {
1913 snesdbg_execute_callback(snes_debug_cb_trace, -1);
1914 }
1915
1916 void snesdbg_set_callback(lua::state& L, lua::state*& cb)
1917 {
1918 cb = &L.get_master();
1919 L.pushlightuserdata(&cb);
1920 L.pushvalue(-2);
1921 L.settable(LUA_REGISTRYINDEX);
1922 }
1923
1924 bool snesdbg_get_bp_enabled(lua::state& L)
1925 {
1926 bool r;
1927 L.getfield(-1, "addr");
1928 r = (L.type(-1) == LUA_TNUMBER);
1929 L.pop(1);
1930 return r;
1931 }
1932
1933 uint32_t snesdbg_get_bp_addr(lua::state& L)
1934 {
1935 uint32_t r = 0;
1936 L.getfield(-1, "addr");
1937 if(L.type(-1) == LUA_TNUMBER)
1938 r = static_cast<uint32_t>(L.tointeger(-1));
1939 L.pop(1);
1940 return r;
1941 }
1942
1943 uint32_t snesdbg_get_bp_data(lua::state& L)
1944 {
1945 signed r = -1;
1946 L.getfield(-1, "data");
1947 if(L.type(-1) == LUA_TNUMBER)
1948 r = static_cast<signed>(L.tointeger(-1));
1949 L.pop(1);
1950 return r;
1951 }
1952
1953 SNES::Debugger::Breakpoint::Mode snesdbg_get_bp_mode(lua::state& L)
1954 {
1955 SNES::Debugger::Breakpoint::Mode r = SNES::Debugger::Breakpoint::Mode::Exec;
1956 L.getfield(-1, "mode");
1957 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "e"))
1958 r = SNES::Debugger::Breakpoint::Mode::Exec;
1959 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "x"))
1960 r = SNES::Debugger::Breakpoint::Mode::Exec;
1961 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "exec"))
1962 r = SNES::Debugger::Breakpoint::Mode::Exec;
1963 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "r"))
1964 r = SNES::Debugger::Breakpoint::Mode::Read;
1965 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "read"))
1966 r = SNES::Debugger::Breakpoint::Mode::Read;
1967 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "w"))
1968 r = SNES::Debugger::Breakpoint::Mode::Write;
1969 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "write"))
1970 r = SNES::Debugger::Breakpoint::Mode::Write;
1971 L.pop(1);
1972 return r;
1973 }
1974
1975 SNES::Debugger::Breakpoint::Source snesdbg_get_bp_source(lua::state& L)
1976 {
1977 SNES::Debugger::Breakpoint::Source r = SNES::Debugger::Breakpoint::Source::CPUBus;
1978 L.getfield(-1, "source");
1979 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "cpubus"))
1980 r = SNES::Debugger::Breakpoint::Source::CPUBus;
1981 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "apuram"))
1982 r = SNES::Debugger::Breakpoint::Source::APURAM;
1983 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "vram"))
1984 r = SNES::Debugger::Breakpoint::Source::VRAM;
1985 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "oam"))
1986 r = SNES::Debugger::Breakpoint::Source::OAM;
1987 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "cgram"))
1988 r = SNES::Debugger::Breakpoint::Source::CGRAM;
1989 L.pop(1);
1990 return r;
1991 }
1992
1993 void snesdbg_get_bp_callback(lua::state& L)
1994 {
1995 L.getfield(-1, "callback");
1996 }
1997
1998 int setdebug(lua::state& L, lua::parameters& P)
1999 {
2000 unsigned r;
2001 int ltbl;
2002
2003 P(r);
2004
2005 if(r >= SNES::Debugger::Breakpoints)
2006 throw std::runtime_error("Bad breakpoint number");
2007 if(P.is_novalue()) {
2008 //Clear breakpoint.
2009 SNES::debugger.breakpoint[r].enabled = false;
2010 return 0;
2011 } else if(P.is_table()) {
2012 P(P.table(ltbl));
2013 L.pushvalue(ltbl);
2014 auto& x = SNES::debugger.breakpoint[r];
2015 x.enabled = snesdbg_get_bp_enabled(L);
2016 x.addr = snesdbg_get_bp_addr(L);
2017 x.data = snesdbg_get_bp_data(L);
2018 x.mode = snesdbg_get_bp_mode(L);
2019 x.source = snesdbg_get_bp_source(L);
2020 snesdbg_get_bp_callback(L);
2021 snesdbg_set_callback(L, snes_debug_cb_keys[r]);
2022 L.pop(2);
2023 return 0;
2024 } else
2025 P.expected("table or nil");
2026 return 0; //NOTREACHED.
2027 }
2028
2029 int setstep(lua::state& L, lua::parameters& P)
2030 {
2031 uint64_t r;
2032 int lfn = 2;
2033
2034 P(r);
2035 if(P.is_function() || P.is_novalue()) lfn = P.skip();
2036
2037 L.pushvalue(lfn);
2038 snesdbg_set_callback(L, snes_debug_cb_trace);
2039 trace_counter = r;
2040 update_trace_hook_state();
2041 L.pop(1);
2042 return 0;
2043 }
2044
2045 int settrace(lua::state& L, lua::parameters& P)
2046 {
2047 std::string r;
2048
2049 P(r);
2050
2051 CORE().command->invoke("tracelog cpu " + r);
2052 return 0;
2053 }
2054
2055 command::fnptr<const std::string&> start_trace(lsnes_cmds, "set-trace", "No description available",
2056 "No description available\n",
2057 [](const std::string& r) throw(std::bad_alloc, std::runtime_error) {
2058 CORE().command->invoke("tracelog cpu " + r);
2059 });
2060
2061 #ifdef BSNES_IS_COMPAT
2062 int enablelayer(lua::state& L, lua::parameters& P)
2063 {
2064 unsigned layer, priority;
2065 bool enabled;
2066
2067 P(layer, priority, enabled);
2068
2069 SNES::ppu.layer_enable(layer, priority, enabled);
2070 return 0;
2071 }
2072 #endif
2073
2074 int smpdisasm(lua::state& L, lua::parameters& P)
2075 {
2076 uint64_t addr;
2077
2078 P(addr);
2079
2080 nall::string _disasm = SNES::smp.disassemble_opcode(addr);
2081 std::string disasm(_disasm, _disasm.length());
2082 L.pushlstring(disasm);
2083 return 1;
2084 }
2085
2086 lua::functions debug_fns_snes(lua_func_misc, "bsnes", {
2087 #ifdef BSNES_IS_COMPAT
2088 {"enablelayer", enablelayer},
2089 #endif
2090 {"smpdisasm", smpdisasm},
2091 });
2092
2093 lua::functions debug_fns_memory(lua_func_misc, "memory", {
2094 {"setdebug", setdebug},
2095 {"setstep", setstep},
2096 {"settrace", settrace},
2097 });
2098 #else
2099 void snesdbg_on_break() {}
2100 void snesdbg_on_trace() {}
2101 #endif
2102
2103 struct oninit {
2104 oninit()
2105 {
2106 register_sysregion_mapping("snes_pal", "SNES");
2107 register_sysregion_mapping("snes_ntsc", "SNES");
2108 register_sysregion_mapping("bsx", "SNES");
2109 register_sysregion_mapping("bsxslotted", "SNES");
2110 register_sysregion_mapping("sufamiturbo", "SNES");
2111 register_sysregion_mapping("sgb_ntsc", "SGB");
2112 register_sysregion_mapping("sgb_pal", "SGB");
2113 }
2114 } _oninit;
2115 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core