?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GB: Fix tracelogger not to screw up breaks
[lsnes.git] / src / emulation / gambatte / core.cpp
blob37c50d737fb0e5ea5974ed236da2945ccd98d8b6
1 /***************************************************************************
2 * Copyright (C) 2012-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 version 2 as *
6 * published by the Free Software Foundation. *
7 * *
8 * This program is distributed in the hope that it will be useful, *
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
11 * GNU General Public License version 2 for more details. *
12 * *
13 * You should have received a copy of the GNU General Public License *
14 * version 2 along with this program; if not, write to the *
15 * Free Software Foundation, Inc., *
16 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
17 ***************************************************************************/
18 #include "lsnes.hpp"
19 #include <sstream>
20 #include <iostream>
21 #include <map>
22 #include <string>
23 #include <vector>
24 #include "disassemble-gb.hpp"
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/settings.hpp"
31 #include "core/framebuffer.hpp"
32 #include "core/window.hpp"
33 #include "interface/callbacks.hpp"
34 #include "interface/cover.hpp"
35 #include "interface/romtype.hpp"
36 #include "library/framebuffer-pixfmt-rgb32.hpp"
37 #include "library/hex.hpp"
38 #include "library/string.hpp"
39 #include "library/controller-data.hpp"
40 #include "library/serialization.hpp"
41 #include "library/minmax.hpp"
42 #include "library/framebuffer.hpp"
43 #define HAVE_CSTDINT
44 #include "libgambatte/include/gambatte.h"
45
46 #define SAMPLES_PER_FRAME 35112
47
48 namespace
49 {
50 settingvar::variable<settingvar::model_bool<settingvar::yes_no>> output_native(lsnes_vset,
51 "gambatte-native-sound", "Gambatte‣Sound Output at native rate", false);
52
53 bool do_reset_flag = false;
54 core_type* internal_rom = NULL;
55 bool rtc_fixed;
56 time_t rtc_fixed_val;
57 gambatte::GB* instance;
58 bool reallocate_debug = false;
59 bool sigillcrash = false;
60 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
61 gambatte::debugbuffer debugbuf;
62 size_t cur_romsize;
63 size_t cur_ramsize;
64 #endif
65 unsigned frame_overflow = 0;
66 std::vector<unsigned char> romdata;
67 uint32_t cover_fbmem[480 * 432];
68 uint32_t primary_framebuffer[160*144];
69 uint32_t accumulator_l = 0;
70 uint32_t accumulator_r = 0;
71 unsigned accumulator_s = 0;
72 bool pflag = false;
73 bool disable_breakpoints = false;
74 bool palette_colors_default[3] = {true, true, true};
75 uint32_t palette_colors[12];
76
77 struct interface_device_reg gb_registers[] = {
78 {"wrambank", []() -> uint64_t { return instance ? instance->getIoRam().first[0x170] & 0x07 : 0; },
79 [](uint64_t v) {}},
80 {"cyclecount", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_CYCLECOUNTER); },
81 [](uint64_t v) {}},
82 {"pc", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_PC); },
83 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_PC, v); }},
84 {"sp", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_SP); },
85 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_SP, v); }},
86 {"hf1", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_HF1); },
87 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_HF1, v); }},
88 {"hf2", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_HF2); },
89 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_HF2, v); }},
90 {"zf", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_ZF); },
91 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_ZF, v); }},
92 {"cf", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_CF); },
93 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_CF, v); }},
94 {"a", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_A); },
95 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_A, v); }},
96 {"b", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_B); },
97 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_B, v); }},
98 {"c", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_C); },
99 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_C, v); }},
100 {"d", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_D); },
101 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_D, v); }},
102 {"e", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_E); },
103 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_E, v); }},
104 {"f", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_F); },
105 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_F, v); }},
106 {"h", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_H); },
107 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_H, v); }},
108 {"l", []() -> uint64_t { return instance->get_cpureg(gambatte::GB::REG_L); },
109 [](uint64_t v) { instance->set_cpureg(gambatte::GB::REG_L, v); }},
110 {NULL, NULL, NULL}
111 };
112
113 //Framebuffer.
114 struct framebuffer::info cover_fbinfo = {
115 &framebuffer::pixfmt_rgb32, //Format.
116 (char*)cover_fbmem, //Memory.
117 480, 432, 1920, //Physical size.
118 480, 432, 1920, //Logical size.
119 0, 0 //Offset.
120 };
121
122 #include "ports.inc"
123
124 time_t walltime_fn()
125 {
126 if(rtc_fixed)
127 return rtc_fixed_val;
128 if(ecore_callbacks)
129 return ecore_callbacks->get_time();
130 else
131 return time(0);
132 }
133
134 class myinput : public gambatte::InputGetter
135 {
136 public:
137 unsigned operator()()
138 {
139 unsigned v = 0;
140 for(unsigned i = 0; i < 8; i++) {
141 if(ecore_callbacks->get_input(0, 1, i))
142 v |= (1 << i);
143 }
144 pflag = true;
145 return v;
146 };
147 } getinput;
148
149 uint64_t get_address(unsigned clazz, unsigned offset)
150 {
151 switch(clazz) {
152 case 0: return 0x1000000 + offset; //BUS.
153 case 1: return offset; //WRAM.
154 case 2: return 0x18000 + offset; //IOAMHRAM
155 case 3: return 0x80000000 + offset; //ROM
156 case 4: return 0x20000 + offset; //SRAM.
157 }
158 return 0xFFFFFFFFFFFFFFFF;
159 }
160
161 void gambatte_read_handler(unsigned clazz, unsigned offset, uint8_t value, bool exec)
162 {
163 if(disable_breakpoints) return;
164 uint64_t _addr = get_address(clazz, offset);
165 if(_addr != 0xFFFFFFFFFFFFFFFFULL) {
166 if(exec)
167 ecore_callbacks->memory_execute(_addr, 0);
168 else
169 ecore_callbacks->memory_read(_addr, value);
170 }
171 }
172
173 void gambatte_write_handler(unsigned clazz, unsigned offset, uint8_t value)
174 {
175 if(disable_breakpoints) return;
176 uint64_t _addr = get_address(clazz, offset);
177 if(_addr != 0xFFFFFFFFFFFFFFFFULL)
178 ecore_callbacks->memory_write(_addr, value);
179 }
180
181 int get_hl(gambatte::GB* instance)
182 {
183 return instance->get_cpureg(gambatte::GB::REG_H) * 256 +
184 instance->get_cpureg(gambatte::GB::REG_L);
185 }
186
187 int get_bc(gambatte::GB* instance)
188 {
189 return instance->get_cpureg(gambatte::GB::REG_B) * 256 +
190 instance->get_cpureg(gambatte::GB::REG_C);
191 }
192
193 int get_de(gambatte::GB* instance)
194 {
195 return instance->get_cpureg(gambatte::GB::REG_D) * 256 +
196 instance->get_cpureg(gambatte::GB::REG_E);
197 }
198
199 //0 => None or already done.
200 //1 => BC
201 //2 => DE
202 //3 => HL
203 //4 => 0xFF00 + C.
204 //5 => Bitops
205 int memclass[] = {
206 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
207 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, //0
208 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, //1
209 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, //2
210 0, 0, 3, 0, 3, 3, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, //3
211 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //4
212 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //5
213 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //6
214 3, 3, 3, 3, 3, 3, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, //7
215 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //8
216 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //9
217 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //A
218 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, //B
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, //C
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //D
221 0, 0, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, //E
222 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //F.
223 };
224
225 const char* hexch = "0123456789abcdef";
226 inline void buffer_h8(char*& ptr, uint8_t v)
227 {
228 *(ptr++) = hexch[v >> 4];
229 *(ptr++) = hexch[v & 15];
230 }
231
232 inline void buffer_h16(char*& ptr, uint16_t v)
233 {
234 *(ptr++) = hexch[v >> 12];
235 *(ptr++) = hexch[(v >> 8) & 15];
236 *(ptr++) = hexch[(v >> 4) & 15];
237 *(ptr++) = hexch[v & 15];
238 }
239
240 inline void buffer_str(char*& ptr, const char* str)
241 {
242 while(*str)
243 *(ptr++) = *(str++);
244 }
245
246 void gambatte_trace_handler(uint16_t _pc)
247 {
248 static char buffer[512];
249 char* buffer_ptr = buffer;
250 int addr = -1;
251 uint16_t opcode;
252 uint32_t pc = _pc;
253 uint16_t offset = 0;
254 std::function<uint8_t()> fetch = [pc, &offset, &buffer_ptr]() -> uint8_t {
255 unsigned addr = pc + offset++;
256 uint8_t v;
257 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
258 disable_breakpoints = true;
259 v = instance->bus_read(addr);
260 disable_breakpoints = false;
261 #endif
262 buffer_h8(buffer_ptr, v);
263 return v;
264 };
265 buffer_h16(buffer_ptr, pc);
266 *(buffer_ptr++) = ' ';
267 auto d = disassemble_gb_opcode(pc, fetch, addr, opcode);
268 while(buffer_ptr < buffer + 12)
269 *(buffer_ptr++) = ' ';
270 buffer_str(buffer_ptr, d.c_str());
271 switch(memclass[opcode >> 8]) {
272 case 1: addr = get_bc(instance); break;
273 case 2: addr = get_de(instance); break;
274 case 3: addr = get_hl(instance); break;
275 case 4: addr = 0xFF00 + instance->get_cpureg(gambatte::GB::REG_C); break;
276 case 5: if((opcode & 7) == 6) addr = get_hl(instance); break;
277 }
278 while(buffer_ptr < buffer + 28)
279 *(buffer_ptr++) = ' ';
280 if(addr >= 0) {
281 buffer_str(buffer_ptr, "[");
282 buffer_h16(buffer_ptr, addr);
283 buffer_str(buffer_ptr, "]");
284 } else
285 buffer_str(buffer_ptr, " ");
286
287 buffer_str(buffer_ptr, "A:");
288 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_A));
289 buffer_str(buffer_ptr, " B:");
290 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_B));
291 buffer_str(buffer_ptr, " C:");
292 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_C));
293 buffer_str(buffer_ptr, " D:");
294 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_D));
295 buffer_str(buffer_ptr, " E:");
296 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_E));
297 buffer_str(buffer_ptr, " H:");
298 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_H));
299 buffer_str(buffer_ptr, " L:");
300 buffer_h8(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_L));
301 buffer_str(buffer_ptr, " SP:");
302 buffer_h16(buffer_ptr, instance->get_cpureg(gambatte::GB::REG_SP));
303 buffer_str(buffer_ptr, " F:");
304 *(buffer_ptr++) = instance->get_cpureg(gambatte::GB::REG_CF) ? 'C' : '-';
305 *(buffer_ptr++) = instance->get_cpureg(gambatte::GB::REG_ZF) ? '-' : 'Z';
306 *(buffer_ptr++) = instance->get_cpureg(gambatte::GB::REG_HF1) ? '1' : '-';
307 *(buffer_ptr++) = instance->get_cpureg(gambatte::GB::REG_HF2) ? '2' : '-';
308 *(buffer_ptr++) = '\0';
309 ecore_callbacks->memory_trace(0, buffer, true);
310 }
311
312 void basic_init()
313 {
314 static bool done = false;
315 if(done)
316 return;
317 done = true;
318 instance = new gambatte::GB;
319 instance->setInputGetter(&getinput);
320 instance->set_walltime_fn(walltime_fn);
321 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
322 uint8_t* tmp = new uint8_t[98816];
323 memset(tmp, 0, 98816);
324 debugbuf.wram = tmp;
325 debugbuf.bus = tmp + 32768;
326 debugbuf.ioamhram = tmp + 98304;
327 debugbuf.read = gambatte_read_handler;
328 debugbuf.write = gambatte_write_handler;
329 debugbuf.trace = gambatte_trace_handler;
330 debugbuf.trace_cpu = false;
331 instance->set_debug_buffer(debugbuf);
332 #endif
333 }
334
335 int load_rom_common(core_romimage* img, unsigned flags, uint64_t rtc_sec, uint64_t rtc_subsec,
336 core_type* inttype, std::map<std::string, std::string>& settings)
337 {
338 basic_init();
339 const char* markup = img[0].markup;
340 int flags2 = 0;
341 if(markup) {
342 flags2 = atoi(markup);
343 flags2 &= 4;
344 }
345 flags |= flags2;
346 const unsigned char* data = img[0].data;
347 size_t size = img[0].size;
348
349 //Reset it really.
350 instance->~GB();
351 memset(instance, 0, sizeof(gambatte::GB));
352 new(instance) gambatte::GB;
353 instance->setInputGetter(&getinput);
354 instance->set_walltime_fn(walltime_fn);
355 memset(primary_framebuffer, 0, sizeof(primary_framebuffer));
356 frame_overflow = 0;
357
358 rtc_fixed = true;
359 rtc_fixed_val = rtc_sec;
360 instance->load(data, size, flags);
361 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
362 size_t sramsize = instance->getSaveRam().second;
363 size_t romsize = size;
364 if(reallocate_debug || cur_ramsize != sramsize || cur_romsize != romsize) {
365 if(debugbuf.cart) delete[] debugbuf.cart;
366 if(debugbuf.sram) delete[] debugbuf.sram;
367 debugbuf.cart = NULL;
368 debugbuf.sram = NULL;
369 if(sramsize) debugbuf.sram = new uint8_t[(sramsize + 4095) >> 12 << 12];
370 if(romsize) debugbuf.cart = new uint8_t[(romsize + 4095) >> 12 << 12];
371 if(sramsize) memset(debugbuf.sram, 0, (sramsize + 4095) >> 12 << 12);
372 if(romsize) memset(debugbuf.cart, 0, (romsize + 4095) >> 12 << 12);
373 memset(debugbuf.wram, 0, 32768);
374 memset(debugbuf.ioamhram, 0, 512);
375 debugbuf.wramcheat.clear();
376 debugbuf.sramcheat.clear();
377 debugbuf.cartcheat.clear();
378 debugbuf.trace_cpu = false;
379 reallocate_debug = false;
380 cur_ramsize = sramsize;
381 cur_romsize = romsize;
382 }
383 instance->set_debug_buffer(debugbuf);
384 #endif
385 sigillcrash = false;
386 #ifdef GAMBATTE_SUPPORTS_EMU_FLAGS
387 unsigned emuflags = 0;
388 if(settings.count("sigillcrash") && settings["sigillcrash"] == "1")
389 emuflags |= 1;
390 sigillcrash = (emuflags & 1);
391 instance->set_emuflags(emuflags);
392 #endif
393 rtc_fixed = false;
394 romdata.resize(size);
395 memcpy(&romdata[0], data, size);
396 internal_rom = inttype;
397 do_reset_flag = false;
398
399 for(unsigned i = 0; i < 12; i++)
400 if(!palette_colors_default[i >> 2])
401 instance->setDmgPaletteColor(i >> 2, i & 3, palette_colors[i]);
402
403 return 1;
404 }
405
406 controller_set gambatte_controllerconfig(std::map<std::string, std::string>& settings)
407 {
408 std::map<std::string, std::string> _settings = settings;
409 controller_set r;
410 r.ports.push_back(&psystem);
411 r.logical_map.push_back(std::make_pair(0, 1));
412 return r;
413 }
414
415 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
416 uint8_t gambatte_bus_read(uint64_t offset)
417 {
418 disable_breakpoints = true;
419 uint8_t val = instance->bus_read(offset);
420 disable_breakpoints = false;
421 return val;
422 }
423
424 void gambatte_bus_write(uint64_t offset, uint8_t data)
425 {
426 disable_breakpoints = true;
427 instance->bus_write(offset, data);
428 disable_breakpoints = false;
429 }
430 #endif
431
432 std::list<core_vma_info> get_VMAlist()
433 {
434 std::list<core_vma_info> vmas;
435 if(!internal_rom)
436 return vmas;
437 core_vma_info sram;
438 core_vma_info wram;
439 core_vma_info vram;
440 core_vma_info ioamhram;
441 core_vma_info rom;
442 core_vma_info bus;
443
444 auto g = instance->getSaveRam();
445 sram.name = "SRAM";
446 sram.base = 0x20000;
447 sram.size = g.second;
448 sram.backing_ram = g.first;
449 sram.endian = -1;
450
451 auto g2 = instance->getWorkRam();
452 wram.name = "WRAM";
453 wram.base = 0;
454 wram.size = g2.second;
455 wram.backing_ram = g2.first;
456 wram.endian = -1;
457
458 auto g3 = instance->getVideoRam();
459 vram.name = "VRAM";
460 vram.base = 0x10000;
461 vram.size = g3.second;
462 vram.backing_ram = g3.first;
463 vram.endian = -1;
464
465 auto g4 = instance->getIoRam();
466 ioamhram.name = "IOAMHRAM";
467 ioamhram.base = 0x18000;
468 ioamhram.size = g4.second;
469 ioamhram.backing_ram = g4.first;
470 ioamhram.endian = -1;
471
472 rom.name = "ROM";
473 rom.base = 0x80000000;
474 rom.size = romdata.size();
475 rom.backing_ram = (void*)&romdata[0];
476 rom.endian = -1;
477 rom.readonly = true;
478
479 if(sram.size)
480 vmas.push_back(sram);
481 vmas.push_back(wram);
482 vmas.push_back(rom);
483 vmas.push_back(vram);
484 vmas.push_back(ioamhram);
485 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
486 bus.name = "BUS";
487 bus.base = 0x1000000;
488 bus.size = 0x10000;
489 bus.backing_ram = NULL;
490 bus.read = gambatte_bus_read;
491 bus.write = gambatte_bus_write;
492 bus.endian = -1;
493 bus.special = true;
494 vmas.push_back(bus);
495 #endif
496 return vmas;
497 }
498
499 std::set<std::string> gambatte_srams()
500 {
501 std::set<std::string> s;
502 if(!internal_rom)
503 return s;
504 auto g = instance->getSaveRam();
505 if(g.second)
506 s.insert("main");
507 s.insert("rtc");
508 return s;
509 }
510
511 std::string get_cartridge_name()
512 {
513 std::ostringstream name;
514 if(romdata.size() < 0x200)
515 return ""; //Bad.
516 for(unsigned i = 0; i < 16; i++) {
517 if(romdata[0x134 + i])
518 name << (char)romdata[0x134 + i];
519 else
520 break;
521 }
522 return name.str();
523 }
524
525 void redraw_cover_fbinfo();
526
527 struct _gambatte_core : public core_core, public core_region
528 {
529 _gambatte_core()
530 : core_core({&psystem}, {
531 {0, "Soft reset", "reset", {}},
532 {1, "Change BG palette", "bgpalette", {
533 {"Color 0","string:[0-9A-Fa-f]{6}"},
534 {"Color 1","string:[0-9A-Fa-f]{6}"},
535 {"Color 2","string:[0-9A-Fa-f]{6}"},
536 {"Color 3","string:[0-9A-Fa-f]{6}"}
537 }},{2, "Change SP1 palette", "sp1palette", {
538 {"Color 0","string:[0-9A-Fa-f]{6}"},
539 {"Color 1","string:[0-9A-Fa-f]{6}"},
540 {"Color 2","string:[0-9A-Fa-f]{6}"},
541 {"Color 3","string:[0-9A-Fa-f]{6}"}
542 }}, {3, "Change SP2 palette", "sp2palette", {
543 {"Color 0","string:[0-9A-Fa-f]{6}"},
544 {"Color 1","string:[0-9A-Fa-f]{6}"},
545 {"Color 2","string:[0-9A-Fa-f]{6}"},
546 {"Color 3","string:[0-9A-Fa-f]{6}"}
547 }}
548 }),
549 core_region({{"world", "World", 0, 0, false, {4389, 262144}, {0}}}) {}
550
551 std::string c_core_identifier() { return "libgambatte "+gambatte::GB::version(); }
552 bool c_set_region(core_region& region) { return (&region == this); }
553 std::pair<uint32_t, uint32_t> c_video_rate() { return std::make_pair(262144, 4389); }
554 double c_get_PAR() { return 1.0; }
555 std::pair<uint32_t, uint32_t> c_audio_rate() {
556 if(output_native)
557 return std::make_pair(2097152, 1);
558 else
559 return std::make_pair(32768, 1);
560 }
561 std::map<std::string, std::vector<char>> c_save_sram() throw(std::bad_alloc) {
562 std::map<std::string, std::vector<char>> s;
563 if(!internal_rom)
564 return s;
565 auto g = instance->getSaveRam();
566 s["main"].resize(g.second);
567 memcpy(&s["main"][0], g.first, g.second);
568 s["rtc"].resize(8);
569 time_t timebase = instance->getRtcBase();
570 for(size_t i = 0; i < 8; i++)
571 s["rtc"][i] = ((unsigned long long)timebase >> (8 * i));
572 return s;
573 }
574 void c_load_sram(std::map<std::string, std::vector<char>>& sram) throw(std::bad_alloc) {
575 if(!internal_rom)
576 return;
577 std::vector<char> x = sram.count("main") ? sram["main"] : std::vector<char>();
578 std::vector<char> x2 = sram.count("rtc") ? sram["rtc"] : std::vector<char>();
579 auto g = instance->getSaveRam();
580 if(x.size()) {
581 if(x.size() != g.second)
582 messages << "WARNING: SRAM 'main': Loaded " << x.size()
583 << " bytes, but the SRAM is " << g.second << "." << std::endl;
584 memcpy(g.first, &x[0], min(x.size(), g.second));
585 }
586 if(x2.size()) {
587 time_t timebase = 0;
588 for(size_t i = 0; i < 8 && i < x2.size(); i++)
589 timebase |= (unsigned long long)(unsigned char)x2[i] << (8 * i);
590 instance->setRtcBase(timebase);
591 }
592 }
593 void c_serialize(std::vector<char>& out) {
594 if(!internal_rom)
595 throw std::runtime_error("Can't save without ROM");
596 instance->saveState(out);
597 size_t osize = out.size();
598 out.resize(osize + 4 * sizeof(primary_framebuffer) / sizeof(primary_framebuffer[0]));
599 for(size_t i = 0; i < sizeof(primary_framebuffer) / sizeof(primary_framebuffer[0]); i++)
600 serialization::u32b(&out[osize + 4 * i], primary_framebuffer[i]);
601 out.push_back(frame_overflow >> 8);
602 out.push_back(frame_overflow);
603 }
604 void c_unserialize(const char* in, size_t insize) {
605 if(!internal_rom)
606 throw std::runtime_error("Can't load without ROM");
607 size_t foffset = insize - 2 - 4 * sizeof(primary_framebuffer) /
608 sizeof(primary_framebuffer[0]);
609 std::vector<char> tmp;
610 tmp.resize(foffset);
611 memcpy(&tmp[0], in, foffset);
612 instance->loadState(tmp);
613 for(size_t i = 0; i < sizeof(primary_framebuffer) / sizeof(primary_framebuffer[0]); i++)
614 primary_framebuffer[i] = serialization::u32b(&in[foffset + 4 * i]);
615
616 unsigned x1 = (unsigned char)in[insize - 2];
617 unsigned x2 = (unsigned char)in[insize - 1];
618 frame_overflow = x1 * 256 + x2;
619 do_reset_flag = false;
620 }
621 core_region& c_get_region() { return *this; }
622 void c_power() {}
623 void c_unload_cartridge() {}
624 std::pair<uint32_t, uint32_t> c_get_scale_factors(uint32_t width, uint32_t height) {
625 return std::make_pair(max(512 / width, (uint32_t)1), max(448 / height, (uint32_t)1));
626 }
627 void c_install_handler() { magic_flags |= 2; }
628 void c_uninstall_handler() {}
629 void c_emulate() {
630 if(!internal_rom)
631 return;
632 bool native_rate = output_native;
633 int16_t reset = ecore_callbacks->get_input(0, 0, 1);
634 if(reset) {
635 instance->reset();
636 messages << "GB(C) reset" << std::endl;
637 }
638 do_reset_flag = false;
639
640 uint32_t samplebuffer[SAMPLES_PER_FRAME + 2064];
641 int16_t soundbuf[2 * (SAMPLES_PER_FRAME + 2064)];
642 size_t emitted = 0;
643 while(true) {
644 unsigned samples_emitted = SAMPLES_PER_FRAME - frame_overflow;
645 long ret = instance->runFor(primary_framebuffer, 160, samplebuffer, samples_emitted);
646 if(native_rate)
647 for(unsigned i = 0; i < samples_emitted; i++) {
648 soundbuf[emitted++] = (int16_t)(samplebuffer[i]);
649 soundbuf[emitted++] = (int16_t)(samplebuffer[i] >> 16);
650 }
651 else
652 for(unsigned i = 0; i < samples_emitted; i++) {
653 uint32_t l = (int32_t)(int16_t)(samplebuffer[i]) + 32768;
654 uint32_t r = (int32_t)(int16_t)(samplebuffer[i] >> 16) + 32768;
655 accumulator_l += l;
656 accumulator_r += r;
657 accumulator_s++;
658 if((accumulator_s & 63) == 0) {
659 int16_t l2 = (accumulator_l >> 6) - 32768;
660 int16_t r2 = (accumulator_r >> 6) - 32768;
661 soundbuf[emitted++] = l2;
662 soundbuf[emitted++] = r2;
663 accumulator_l = accumulator_r = 0;
664 accumulator_s = 0;
665 }
666 }
667 ecore_callbacks->timer_tick(samples_emitted, 2097152);
668 frame_overflow += samples_emitted;
669 if(frame_overflow >= SAMPLES_PER_FRAME) {
670 frame_overflow -= SAMPLES_PER_FRAME;
671 break;
672 }
673 }
674 framebuffer::info inf;
675 inf.type = &framebuffer::pixfmt_rgb32;
676 inf.mem = const_cast<char*>(reinterpret_cast<const char*>(primary_framebuffer));
677 inf.physwidth = 160;
678 inf.physheight = 144;
679 inf.physstride = 640;
680 inf.width = 160;
681 inf.height = 144;
682 inf.stride = 640;
683 inf.offset_x = 0;
684 inf.offset_y = 0;
685
686 framebuffer::raw ls(inf);
687 ecore_callbacks->output_frame(ls, 262144, 4389);
688 audioapi_submit_buffer(soundbuf, emitted / 2, true, native_rate ? 2097152 : 32768);
689 }
690 void c_runtosave() {}
691 bool c_get_pflag() { return pflag; }
692 void c_set_pflag(bool _pflag) { pflag = _pflag; }
693 framebuffer::raw& c_draw_cover() {
694 static framebuffer::raw x(cover_fbinfo);
695 redraw_cover_fbinfo();
696 return x;
697 }
698 std::string c_get_core_shortname() { return "gambatte"+gambatte::GB::version(); }
699 void c_pre_emulate_frame(controller_frame& cf) {
700 cf.axis3(0, 0, 1, do_reset_flag ? 1 : 0);
701 }
702 void c_execute_action(unsigned id, const std::vector<interface_action_paramval>& p)
703 {
704 uint32_t a, b, c, d;
705 switch(id) {
706 case 0: //Soft reset.
707 do_reset_flag = true;
708 break;
709 case 1: //Change DMG BG palette.
710 case 2: //Change DMG SP1 palette.
711 case 3: //Change DMG SP2 palette.
712 a = strtoul(p[0].s.c_str(), NULL, 16);
713 b = strtoul(p[1].s.c_str(), NULL, 16);
714 c = strtoul(p[2].s.c_str(), NULL, 16);
715 d = strtoul(p[3].s.c_str(), NULL, 16);
716 palette_colors[4 * (id - 1) + 0] = a;
717 palette_colors[4 * (id - 1) + 1] = b;
718 palette_colors[4 * (id - 1) + 2] = c;
719 palette_colors[4 * (id - 1) + 3] = d;
720 palette_colors_default[id - 1] = false;
721 if(instance) {
722 instance->setDmgPaletteColor(id - 1, 0, a);
723 instance->setDmgPaletteColor(id - 1, 1, b);
724 instance->setDmgPaletteColor(id - 1, 2, c);
725 instance->setDmgPaletteColor(id - 1, 3, d);
726 }
727 }
728 }
729 const interface_device_reg* c_get_registers() { return gb_registers; }
730 unsigned c_action_flags(unsigned id) { return (id < 4) ? 1 : 0; }
731 int c_reset_action(bool hard) { return hard ? -1 : 0; }
732 std::pair<uint64_t, uint64_t> c_get_bus_map()
733 {
734 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
735 return std::make_pair(0x1000000, 0x10000);
736 #else
737 return std::make_pair(0, 0);
738 #endif
739 }
740 std::list<core_vma_info> c_vma_list() { return get_VMAlist(); }
741 std::set<std::string> c_srams() { return gambatte_srams(); }
742 void c_set_debug_flags(uint64_t addr, unsigned int sflags, unsigned int cflags)
743 {
744 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
745 if(addr == 0 && sflags & 8) debugbuf.trace_cpu = true;
746 if(addr == 0 && cflags & 8) debugbuf.trace_cpu = false;
747 if(addr >= 0 && addr < 32768) {
748 debugbuf.wram[addr] |= (sflags & 7);
749 debugbuf.wram[addr] &= ~(cflags & 7);
750 } else if(addr >= 0x20000 && addr < 0x20000 + instance->getSaveRam().second) {
751 debugbuf.sram[addr - 0x20000] |= (sflags & 7);
752 debugbuf.sram[addr - 0x20000] &= ~(cflags & 7);
753 } else if(addr >= 0x18000 && addr < 0x18200) {
754 debugbuf.ioamhram[addr - 0x18000] |= (sflags & 7);
755 debugbuf.ioamhram[addr - 0x18000] &= ~(cflags & 7);
756 } else if(addr >= 0x80000000 && addr < 0x80000000 + romdata.size()) {
757 debugbuf.cart[addr - 0x80000000] |= (sflags & 7);
758 debugbuf.cart[addr - 0x80000000] &= ~(cflags & 7);
759 } else if(addr >= 0x1000000 && addr < 0x1010000) {
760 debugbuf.bus[addr - 0x1000000] |= (sflags & 7);
761 debugbuf.bus[addr - 0x1000000] &= ~(cflags & 7);
762 } else if(addr == 0xFFFFFFFFFFFFFFFFULL) {
763 //Set/Clear every known debug.
764 for(unsigned i = 0; i < 32768; i++) {
765 debugbuf.wram[i] |= ((sflags & 7) << 4);
766 debugbuf.wram[i] &= ~((cflags & 7) << 4);
767 }
768 for(unsigned i = 0; i < 65536; i++) {
769 debugbuf.bus[i] |= ((sflags & 7) << 4);
770 debugbuf.bus[i] &= ~((cflags & 7) << 4);
771 }
772 for(unsigned i = 0; i < 512; i++) {
773 debugbuf.ioamhram[i] |= ((sflags & 7) << 4);
774 debugbuf.ioamhram[i] &= ~((cflags & 7) << 4);
775 }
776 for(unsigned i = 0; i < instance->getSaveRam().second; i++) {
777 debugbuf.sram[i] |= ((sflags & 7) << 4);
778 debugbuf.sram[i] &= ~((cflags & 7) << 4);
779 }
780 for(unsigned i = 0; i < romdata.size(); i++) {
781 debugbuf.cart[i] |= ((sflags & 7) << 4);
782 debugbuf.cart[i] &= ~((cflags & 7) << 4);
783 }
784 }
785 #endif
786 }
787 void c_set_cheat(uint64_t addr, uint64_t value, bool set)
788 {
789 #ifdef GAMBATTE_SUPPORTS_ADV_DEBUG
790 if(addr >= 0 && addr < 32768) {
791 if(set) {
792 debugbuf.wram[addr] |= 8;
793 debugbuf.wramcheat[addr] = value;
794 } else {
795 debugbuf.wram[addr] &= ~8;
796 debugbuf.wramcheat.erase(addr);
797 }
798 } else if(addr >= 0x20000 && addr < 0x20000 + instance->getSaveRam().second) {
799 auto addr2 = addr - 0x20000;
800 if(set) {
801 debugbuf.sram[addr2] |= 8;
802 debugbuf.sramcheat[addr2] = value;
803 } else {
804 debugbuf.sram[addr2] &= ~8;
805 debugbuf.sramcheat.erase(addr2);
806 }
807 } else if(addr >= 0x80000000 && addr < 0x80000000 + romdata.size()) {
808 auto addr2 = addr - 0x80000000;
809 if(set) {
810 debugbuf.cart[addr2] |= 8;
811 debugbuf.cartcheat[addr2] = value;
812 } else {
813 debugbuf.cart[addr2] &= ~8;
814 debugbuf.cartcheat.erase(addr2);
815 }
816 }
817 #endif
818 }
819 void c_debug_reset()
820 {
821 //Next load will reset trace.
822 reallocate_debug = true;
823 palette_colors_default[0] = true;
824 palette_colors_default[1] = true;
825 palette_colors_default[2] = true;
826 }
827 std::vector<std::string> c_get_trace_cpus()
828 {
829 std::vector<std::string> r;
830 r.push_back("cpu");
831 return r;
832 }
833 } gambatte_core;
834
835 std::vector<core_setting_value_param> boolean_values = {{"0", "False", 0}, {"1", "True", 1}};
836 core_setting_group gambatte_settings = {
837 #ifdef GAMBATTE_SUPPORTS_EMU_FLAGS
838 {"sigillcrash", "Crash on SIGILL", "0", boolean_values},
839 #endif
840 };
841
842 struct _type_dmg : public core_type, public core_sysregion
843 {
844 _type_dmg()
845 : core_type({{
846 .iname = "dmg",
847 .hname = "Game Boy",
848 .id = 1,
849 .sysname = "Gameboy",
850 .bios = NULL,
851 .regions = {&gambatte_core},
852 .images = {{"rom", "Cartridge ROM", 1, 0, 0, "gb;dmg"}},
853 .settings = gambatte_settings,
854 .core = &gambatte_core,
855 }}),
856 core_sysregion("gdmg", *this, gambatte_core) {}
857
858 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
859 uint64_t secs, uint64_t subsecs)
860 {
861 return load_rom_common(img, gambatte::GB::FORCE_DMG, secs, subsecs, this, settings);
862 }
863 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
864 {
865 return gambatte_controllerconfig(settings);
866 }
867 } type_dmg;
868
869 struct _type_gbc : public core_type, public core_sysregion
870 {
871 _type_gbc()
872 : core_type({{
873 .iname = "gbc",
874 .hname = "Game Boy Color",
875 .id = 0,
876 .sysname = "Gameboy",
877 .bios = NULL,
878 .regions = {&gambatte_core},
879 .images = {{"rom", "Cartridge ROM", 1, 0, 0, "gbc;cgb"}},
880 .settings = gambatte_settings,
881 .core = &gambatte_core,
882 }}),
883 core_sysregion("ggbc", *this, gambatte_core) {}
884
885 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
886 uint64_t secs, uint64_t subsecs)
887 {
888 return load_rom_common(img, 0, secs, subsecs, this, settings);
889 }
890 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
891 {
892 return gambatte_controllerconfig(settings);
893 }
894 } type_gbc;
895
896 struct _type_gbca : public core_type, public core_sysregion
897 {
898 _type_gbca()
899 : core_type({{
900 .iname = "gbc_gba",
901 .hname = "Game Boy Color (GBA)",
902 .id = 2,
903 .sysname = "Gameboy",
904 .bios = NULL,
905 .regions = {&gambatte_core},
906 .images = {{"rom", "Cartridge ROM", 1, 0, 0, ""}},
907 .settings = gambatte_settings,
908 .core = &gambatte_core,
909 }}),
910 core_sysregion("ggbca", *this, gambatte_core) {}
911
912 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
913 uint64_t secs, uint64_t subsecs)
914 {
915 return load_rom_common(img, gambatte::GB::GBA_CGB, secs, subsecs, this, settings);
916 }
917 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
918 {
919 return gambatte_controllerconfig(settings);
920 }
921 } type_gbca;
922
923 void redraw_cover_fbinfo()
924 {
925 for(size_t i = 0; i < sizeof(cover_fbmem) / sizeof(cover_fbmem[0]); i++)
926 cover_fbmem[i] = 0x00000000;
927 std::string ident = gambatte_core.get_core_identifier();
928 cover_render_string(cover_fbmem, 0, 0, ident, 0xFFFFFF, 0x00000, 480, 432, 1920, 4);
929 cover_render_string(cover_fbmem, 0, 16, "Internal ROM name: " + get_cartridge_name(),
930 0xFFFFFF, 0x00000, 480, 432, 1920, 4);
931 unsigned y = 32;
932 for(auto i : cover_information()) {
933 cover_render_string(cover_fbmem, 0, y, i, 0xFFFFFF, 0x000000, 480, 432, 1920, 4);
934 y += 16;
935 }
936 if(sigillcrash) {
937 cover_render_string(cover_fbmem, 0, y, "Crash on SIGILL enabled", 0xFFFFFF, 0x000000, 480,
938 432, 1920, 4);
939 y += 16;
940 }
941 }
942
943 std::vector<char> cmp_save;
944
945 command::fnptr<> cmp_save1(lsnes_cmd, "set-cmp-save", "", "\n", []() throw(std::bad_alloc,
946 std::runtime_error) {
947 if(!internal_rom)
948 return;
949 instance->saveState(cmp_save);
950 });
951
952 command::fnptr<> cmp_save2(lsnes_cmd, "do-cmp-save", "", "\n", []() throw(std::bad_alloc,
953 std::runtime_error) {
954 std::vector<char> x;
955 if(!internal_rom)
956 return;
957 instance->saveState(x, cmp_save);
958 });
959
960 struct oninit {
961 oninit()
962 {
963 register_sysregion_mapping("gdmg", "GB");
964 register_sysregion_mapping("ggbc", "GBC");
965 register_sysregion_mapping("ggbca", "GBC");
966 }
967 } _oninit;
968 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core