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