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