#include <string.h>\r
#include "../pico_int.h"\r
#include "ym2612.h"\r
+#include "ym2413.h"\r
#include "sn76496.h"\r
-#include "emu2413/emu2413.h"\r
#include "../cd/megasd.h"\r
#include "resampler.h"\r
#include "mix.h"\r
// cdda output buffer\r
s16 cdda_out_buffer[2*1152];\r
\r
-// sn76496\r
-extern int *sn76496_regs;\r
-\r
// FM resampling polyphase FIR\r
static resampler_t *fmresampler;\r
static int (*PsndFMUpdate)(s32 *buffer, int length, int stereo, int is_buf_empty);\r
\r
-// ym2413\r
-static OPLL *opll = NULL;\r
-static struct {\r
- uint32_t adr;\r
- uint8_t reg[sizeof(opll->reg)];\r
-} opll_buf;\r
-\r
-\r
-void YM2413_regWrite(unsigned data){\r
- OPLL_writeIO(opll,0,data);\r
-}\r
-void YM2413_dataWrite(unsigned data){\r
- OPLL_writeIO(opll,1,data);\r
-}\r
-\r
-PICO_INTERNAL void *YM2413GetRegs(void)\r
-{\r
- memcpy(opll_buf.reg, opll->reg, sizeof(opll->reg));\r
- opll_buf.adr = opll->adr;\r
- return &opll_buf;\r
-}\r
-\r
-PICO_INTERNAL void YM2413UnpackState(void)\r
-{\r
- int i;\r
-\r
- for (i = sizeof(opll->reg)-1; i >= 0; i--) {\r
- OPLL_writeIO(opll, 0, i);\r
- OPLL_writeIO(opll, 1, opll_buf.reg[i]);\r
- }\r
- opll->adr = opll_buf.adr;\r
-}\r
-\r
PICO_INTERNAL void PsndInit(void)\r
{\r
opll = OPLL_new(OSC_NTSC/15, OSC_NTSC/15/72);\r
--- /dev/null
+/* PicoDrive's wrapper for emu2413
+ */
+
+#include "emu2413/emu2413.c"
+
+// the one instance that can be in a Mark III
+OPLL *opll = NULL;
+
+
+void YM2413_regWrite(unsigned data){
+ OPLL_writeIO(opll,0,data);
+}
+
+void YM2413_dataWrite(unsigned data){
+ OPLL_writeIO(opll,1,data);
+}
+
+
+// state saving/loading - old save states only have adr and reg saved, new
+// saves have necessary internal state data as well. Most of the state is
+// recovered from the registers, which keeps the internal state data smaller.
+
+#include "../state.h"
+
+#define SLOT_SIZE_MIN 12
+#define OTHER_SIZE_MIN 32
+
+static size_t save_slot(u8 *buf, const OPLL_SLOT *slot)
+{
+ size_t b = 0;
+
+ b++; // length, assumes slot state won't grow beyond 255
+ save_u32(buf, &b, slot->pg_phase);
+ save_u8_(buf, &b, slot->key_flag);
+ save_u8_(buf, &b, slot->eg_state);
+ save_u8_(buf, &b, slot->eg_out);
+ save_s16(buf, &b, slot->output[0]);
+ save_s16(buf, &b, slot->output[1]);
+
+ //printf("slot size: %zd\n", b);
+ assert(b >= SLOT_SIZE_MIN);
+ assert(b < 256u);
+ buf[0] = b - 1;
+ return b;
+}
+
+static void load_slot(const u8 *buf, OPLL_SLOT *slot)
+{
+ size_t b = 0;
+
+ slot->pg_phase = load_u32(buf, &b);
+ slot->key_flag = load_u8_(buf, &b);
+ slot->eg_state = load_u8_(buf, &b);
+ slot->eg_out = load_u8_(buf, &b);
+ slot->output[0] = load_s16(buf, &b);
+ slot->output[1] = load_s16(buf, &b);
+
+ slot->pg_out = slot->pg_phase >> DP_BASE_BITS;
+}
+
+size_t ym2413_pack_state(void *buf_, size_t size)
+{
+ size_t i, b = 0;
+ u8 *buf = buf_;
+
+ // regs and adr first, for backwards compatibility
+ save_u32(buf, &b, opll->adr);
+ for (i = 0; i < 0x40; i++)
+ save_u8_(buf, &b, opll->reg[i]);
+
+ // user patches only, all others are read-only anyway
+ for (i = 0; i < 18; i++)
+ b += save_slot(&buf[b], &opll->slot[i]);
+
+ for (i = 0; i < 9; i++)
+ save_u8_(buf, &b, opll->patch_number[i]);
+ save_u32(buf, &b, opll->slot_key_status);
+ save_u32(buf, &b, opll->eg_counter);
+ save_u8_(buf, &b, opll->lfo_am);
+ save_u32(buf, &b, opll->pm_phase);
+ save_s32(buf, &b, opll->am_phase);
+ save_u32(buf, &b, opll->noise);
+ save_u16(buf, &b, opll->short_noise);
+
+ printf("ym2413 state size: %zu\n", b);
+ assert(b <= size);
+ return b;
+}
+
+void ym2413_unpack_state(const void *buf_, size_t size)
+{
+ const u8 *buf = buf_;
+ size_t i, b = 0;
+
+ // registers, write to opll too to take over to internal data structures
+ opll->adr = load_u32(buf, &b);
+ for (i = 0; i < 0x40; i++) {
+ opll->reg[i] = load_u8_(buf, &b);
+ // skip the shadow registers
+ if ((i & 0xf) < 9 || (i & 0x30) == 0)
+ OPLL_writeReg(opll, i, opll->reg[i]);
+ }
+
+ if (b >= size) return; // old save
+
+ for (i = 0; i < 18; i++) {
+ u8 sz = load_u8_(buf, &b);
+ load_slot(&buf[b], &opll->slot[i]);
+ b += sz;
+ }
+
+ for (i = 0; i < 9; i++)
+ opll->patch_number[i] = load_u8_(buf, &b);
+ opll->slot_key_status = load_u32(buf, &b);
+ opll->eg_counter = load_u32(buf, &b);
+ opll->lfo_am = load_u8_(buf, &b);
+ opll->pm_phase = load_u32(buf, &b);
+ opll->am_phase = load_s32(buf, &b);
+ opll->noise = load_u32(buf, &b);
+ opll->short_noise = load_u16(buf, &b);
+
+ OPLL_forceRefresh(opll);
+}
+
\r
#include <cpu/sh2/sh2.h>\r
#include "sound/ym2612.h"\r
-#include "sound/emu2413/emu2413.h"\r
+#include "sound/ym2413.h"\r
+#include "sound/sn76496.h"\r
#include "cd/megasd.h"\r
#include "state.h"\r
\r
-// sn76496 & ym2413\r
-extern int *sn76496_regs;\r
-\r
static arearw *areaRead;\r
static arearw *areaWrite;\r
static areaeof *areaEof;\r
{\r
char sbuff[32] = "Saving.. ";\r
unsigned char buff[0x60], buff_z80[Z80_STATE_SIZE];\r
- void *ym_regs = YM2612GetRegs();\r
void *buf2 = NULL;\r
int ver = 0x0191; // not really used..\r
int retval = -1;\r
CHECKED_WRITE(CHUNK_PICO, sizeof(PicoPicohw), &PicoPicohw);\r
} else {\r
#ifdef __GP2X__\r
+ void *ym_regs = YM2612GetRegs();\r
ym2612_pack_state_old();\r
- ym_regs = YM2612GetRegs();\r
CHECKED_WRITE(CHUNK_FM, 0x200+4, ym_regs);\r
#else\r
// write fm state first since timer load needs OPN.ST.mode\r
}\r
else {\r
CHECKED_WRITE_BUFF(CHUNK_SMS, Pico.ms);\r
- ym_regs = YM2413GetRegs();\r
- CHECKED_WRITE(CHUNK_YM2413, 0x40+4, ym_regs);\r
+ // only store the FM unit state if it was really used\r
+ if (Pico.m.hardware & PMS_HW_FMUSED) {\r
+ len = ym2413_pack_state(buf2, CHUNK_LIMIT_W);\r
+ CHECKED_WRITE(CHUNK_YM2413, len, buf2);\r
+ }\r
}\r
CHECKED_WRITE(CHUNK_PSG, 28*4, sn76496_regs);\r
\r
case CHUNK_IOPORTS: CHECKED_READ_BUFF(PicoMem.ioports); break;\r
case CHUNK_PSG: CHECKED_READ2(28*4, sn76496_regs); break;\r
case CHUNK_YM2413:\r
- ym_regs = YM2413GetRegs();\r
- CHECKED_READ2(0x40+4, ym_regs);\r
- YM2413UnpackState();\r
+ CHECKED_READ(len, buf);\r
+ ym2413_unpack_state(buf, len);\r
+ Pico.m.hardware |= PMS_HW_FMUSED;\r
break;\r
case CHUNK_FM:\r
ym_regs = YM2612GetRegs();\r
notaz.gp2x.de / picodrive.git / commitdiff