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