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