X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=e232d05a47a19af3667f51ccc6709ff1ff74908b;hb=de74f59932e94887debf30e5ec437d7f63591f74;hp=b3e238b666105662be049e71ff2d1a24936ae1fa;hpb=7a8d521fba9c86ae7b51369ce061bf63112b745f;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index b3e238b6..e232d05a 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -21,7 +21,9 @@ * Handles all CD-ROM registers and functions. */ +#include #include "cdrom.h" +#include "misc.h" #include "ppf.h" #include "psxdma.h" #include "arm_features.h" @@ -35,7 +37,8 @@ #if 0 #define CDR_LOG_I SysPrintf #else -#define CDR_LOG_I log_unhandled +#define CDR_LOG_I(fmt, ...) \ + log_unhandled("%u cdrom: " fmt, psxRegs.cycle, ##__VA_ARGS__) #endif #if 0 #define CDR_LOG_IO SysPrintf @@ -63,7 +66,8 @@ static struct { unsigned char Absolute[3]; } subq; unsigned char TrackChanged; - unsigned char unused3[3]; + unsigned char ReportDelay; + unsigned char unused3[2]; unsigned int freeze_ver; unsigned char Prev[4]; @@ -76,7 +80,7 @@ static struct { unsigned char ResultP; unsigned char ResultReady; unsigned char Cmd; - unsigned char unused4; + unsigned char SubqForwardSectors; unsigned char SetlocPending; u32 Reading; @@ -100,14 +104,14 @@ static struct { u16 CmdInProgress; u8 Irq1Pending; u8 unused5; - u32 unused6; + u32 LastReadCycles; u8 unused7; u8 DriveState; u8 FastForward; u8 FastBackward; - u8 unused8; + u8 errorRetryhack; u8 AttenuatorLeftToLeft, AttenuatorLeftToRight; u8 AttenuatorRightToRight, AttenuatorRightToLeft; @@ -208,6 +212,7 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define cdReadTime (PSXCLK / 75) #define LOCL_INVALID 0xff +#define SUBQ_FORWARD_SECTORS 2u enum drive_state { DRIVESTATE_STANDBY = 0, // pause, play, read @@ -296,8 +301,8 @@ static void setIrq(int log_cmd) if (cdr.Stat) { int i; - SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ", - psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat); + CDR_LOG_I("CDR IRQ=%d cmd %02x stat %02x: ", + !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat); for (i = 0; i < cdr.ResultC; i++) SysPrintf("%02x ", cdr.Result[i]); SysPrintf("\n"); @@ -309,7 +314,7 @@ static void setIrq(int log_cmd) // (yes it's slow, but you probably don't want to modify it) void cdrLidSeekInterrupt(void) { - CDR_LOG_I("%u %s cdr.DriveState=%d\n", psxRegs.cycle, __func__, cdr.DriveState); + CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState); switch (cdr.DriveState) { default: @@ -323,6 +328,7 @@ void cdrLidSeekInterrupt(void) if (stat.Status & STATUS_SHELLOPEN) { + memset(cdr.Prev, 0xff, sizeof(cdr.Prev)); cdr.DriveState = DRIVESTATE_LID_OPEN; CDRLID_INT(0x800); } @@ -447,11 +453,10 @@ static void generate_subq(const u8 *time) cdr.subq.Absolute[2] = itob(time[2]); } -static int ReadTrack(const u8 *time) { +static int ReadTrack(const u8 *time) +{ unsigned char tmp[3]; - struct SubQ *subq; int read_ok; - u16 crc; tmp[0] = itob(time[0]); tmp[1] = itob(time[1]); @@ -463,12 +468,20 @@ static int ReadTrack(const u8 *time) { CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]); read_ok = CDR_readTrack(tmp); - memcpy(cdr.Prev, tmp, 3); + if (read_ok) + memcpy(cdr.Prev, tmp, 3); + return read_ok; +} + +static void UpdateSubq(const u8 *time) +{ + const struct SubQ *subq; + u16 crc; if (CheckSBI(time)) - return read_ok; + return; - subq = (struct SubQ *)CDR_getBufferSub(); + subq = (struct SubQ *)CDR_getBufferSub(MSF2SECT(time[0], time[1], time[2])); if (subq != NULL && cdr.CurTrack == 1) { crc = calcCrc((u8 *)subq + 12, 10); if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { @@ -478,8 +491,8 @@ static int ReadTrack(const u8 *time) { memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3); } else { - CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n", - tmp[0], tmp[1], tmp[2]); + CDR_LOG_I("subq bad crc @%02d:%02d:%02d\n", + time[0], time[1], time[2]); } } else { @@ -490,8 +503,6 @@ static int ReadTrack(const u8 *time) { cdr.subq.Track, cdr.subq.Index, cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2], cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]); - - return read_ok; } static void cdrPlayInterrupt_Autopause() @@ -515,7 +526,9 @@ static void cdrPlayInterrupt_Autopause() StopCdda(); SetPlaySeekRead(cdr.StatP, 0); } - else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) { + else if ((cdr.Mode & MODE_REPORT) && !cdr.ReportDelay && + ((cdr.subq.Absolute[2] & 0x0f) == 0 || cdr.FastForward || cdr.FastBackward)) + { cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.subq.Track; cdr.Result[2] = cdr.subq.Index; @@ -551,39 +564,77 @@ static void cdrPlayInterrupt_Autopause() SetResultSize(8); setIrq(0x1001); } + + if (cdr.ReportDelay) + cdr.ReportDelay--; } +// LastReadCycles static int cdrSeekTime(unsigned char *target) { int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); - int seekTime = abs(diff) * (cdReadTime / 200); - /* - * Gameblabla : - * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball - * and was unreliable for that game. - * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly. - * - * Obviously, this isn't perfect but right now, it should be a bit better. - * Games to test this against if you change that setting : - * - Driver (titlescreen music delay and retry mission) - * - Worms Pinball (Will either not boot or crash in the memory card screen) - * - Viewpoint (short pauses if the delay in the ingame music is too long) - * - * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping. - * However, 1000000 is not enough for Worms Pinball to reliably boot. - */ - if(seekTime > 3386880 * 2) seekTime = 3386880 * 2; + int pausePenalty, seekTime = abs(diff) * (cdReadTime / 2000); + seekTime = MAX_VALUE(seekTime, 20000); + + // need this stupidly long penalty or else Spyro2 intro desyncs + pausePenalty = (s32)(psxRegs.cycle - cdr.LastReadCycles) > cdReadTime * 4 ? cdReadTime * 25 : 0; + seekTime += pausePenalty; + + seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3); CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime); return seekTime; } +static u32 cdrAlignTimingHack(u32 cycles) +{ + /* + * timing hack for T'ai Fu - Wrath of the Tiger: + * The game has a bug where it issues some cdc commands from a low priority + * vint handler, however there is a higher priority default bios handler + * that acks the vint irq and returns, so game's handler is not reached + * (see bios irq handler chains at e004 and the game's irq handling func + * at 80036810). For the game to work, vint has to arrive after the bios + * vint handler rejects some other irq (of which only cd and rcnt2 are + * active), but before the game's handler loop reads I_STAT. The time + * window for this is quite small (~1k cycles of so). Apparently this + * somehow happens naturally on the real hardware. + * + * Note: always enforcing this breaks other games like Crash PAL version + * (inputs get dropped because bios handler doesn't see interrupts). + */ + u32 vint_rel; + if (psxRegs.cycle - rcnts[3].cycleStart > 250000) + return cycles; + vint_rel = rcnts[3].cycleStart + 63000 - psxRegs.cycle; + vint_rel += PSXCLK / 60; + while ((s32)(vint_rel - cycles) < 0) + vint_rel += PSXCLK / 60; + return vint_rel; +} + static void cdrUpdateTransferBuf(const u8 *buf); static void cdrReadInterrupt(void); static void cdrPrepCdda(s16 *buf, int samples); static void cdrAttenuate(s16 *buf, int samples, int stereo); +static void msfiAdd(u8 *msfi, u32 count) +{ + assert(count < 75); + msfi[2] += count; + if (msfi[2] >= 75) { + msfi[2] -= 75; + msfi[1]++; + if (msfi[1] == 60) { + msfi[1] = 0; + msfi[0]++; + } + } +} + void cdrPlayReadInterrupt(void) { + cdr.LastReadCycles = psxRegs.cycle; + if (cdr.Reading) { cdrReadInterrupt(); return; @@ -614,15 +665,7 @@ void cdrPlayReadInterrupt(void) cdr.FirstSector = 0; } - cdr.SetSectorPlay[2]++; - if (cdr.SetSectorPlay[2] == 75) { - cdr.SetSectorPlay[2] = 0; - cdr.SetSectorPlay[1]++; - if (cdr.SetSectorPlay[1] == 60) { - cdr.SetSectorPlay[1] = 0; - cdr.SetSectorPlay[0]++; - } - } + msfiAdd(cdr.SetSectorPlay, 1); // update for CdlGetlocP/autopause generate_subq(cdr.SetSectorPlay); @@ -636,7 +679,7 @@ void cdrPlayReadInterrupt(void) void cdrInterrupt(void) { int start_rotating = 0; int error = 0; - unsigned int seekTime = 0; + u32 cycles, seekTime = 0; u32 second_resp_time = 0; const void *buf; u8 ParamC; @@ -647,15 +690,16 @@ void cdrInterrupt(void) { int i; if (cdr.Stat) { - CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n", - psxRegs.cycle, cdr.CmdInProgress, cdr.Stat); + CDR_LOG_I("cmd %02x with irqstat %x\n", + cdr.CmdInProgress, cdr.Stat); return; } if (cdr.Irq1Pending) { // hand out the "newest" sector, according to nocash cdrUpdateTransferBuf(CDR_getBuffer()); - CDR_LOG_I("cdrom: %x:%02x:%02x loaded on ack\n", - cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + CDR_LOG_I("%x:%02x:%02x loaded on ack, cmd=%02x res=%02x\n", + cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2], + cdr.CmdInProgress, cdr.Irq1Pending); SetResultSize(1); cdr.Result[0] = cdr.Irq1Pending; cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady; @@ -712,6 +756,8 @@ void cdrInterrupt(void) { if (((cdr.Param[0] & 0x0F) > 0x09) || (cdr.Param[0] > 0x99) || ((cdr.Param[1] & 0x0F) > 0x09) || (cdr.Param[1] >= 0x60) || ((cdr.Param[2] & 0x0F) > 0x09) || (cdr.Param[2] >= 0x75)) { CDR_LOG_I("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]); + if (++cdr.errorRetryhack > 100) + break; error = ERROR_INVALIDARG; goto set_error; } @@ -722,6 +768,7 @@ void cdrInterrupt(void) { memcpy(cdr.SetSector, set_loc, 3); cdr.SetSector[3] = 0; cdr.SetlocPending = 1; + cdr.errorRetryhack = 0; } break; @@ -772,10 +819,12 @@ void cdrInterrupt(void) { - plays tracks without retry play */ Find_CurTrack(cdr.SetSectorPlay); - ReadTrack(cdr.SetSectorPlay); + generate_subq(cdr.SetSectorPlay); cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; cdr.TrackChanged = FALSE; cdr.FirstSector = 1; + cdr.ReportDelay = 60; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); @@ -870,7 +919,7 @@ void cdrInterrupt(void) { } else { - second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000); + second_resp_time = (((cdr.Mode & MODE_SPEED) ? 1 : 2) * 1097107); } SetPlaySeekRead(cdr.StatP, 0); break; @@ -886,7 +935,7 @@ void cdrInterrupt(void) { SetPlaySeekRead(cdr.StatP, 0); cdr.LocL[0] = LOCL_INVALID; cdr.Muted = FALSE; - cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */ + cdr.Mode = MODE_SIZE_2340; /* This fixes This is Football 2, Pooh's Party lockups */ second_resp_time = not_ready ? 70000 : 4100000; start_rotating = 1; break; @@ -1013,6 +1062,7 @@ void cdrInterrupt(void) { read_ok = ReadTrack(cdr.SetSectorPlay); if (read_ok && (buf = CDR_getBuffer())) memcpy(cdr.LocL, buf, 8); + UpdateSubq(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; break; @@ -1112,10 +1162,15 @@ void cdrInterrupt(void) { // Fighting Force 2 - update subq time immediately // - fixes new game - ReadTrack(cdr.SetSectorPlay); + UpdateSubq(cdr.SetSectorPlay); cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; - CDRPLAYREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1); + cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2; + cycles += seekTime; + if (Config.hacks.cdr_read_timing) + cycles = cdrAlignTimingHack(cycles); + CDRPLAYREAD_INT(cycles, 1); SetPlaySeekRead(cdr.StatP, STATUS_SEEK); start_rotating = 1; @@ -1127,7 +1182,7 @@ void cdrInterrupt(void) { // FALLTHROUGH set_error: - CDR_LOG_I("cdrom: cmd %02x error %02x\n", Cmd, error); + CDR_LOG_I("cmd %02x error %02x\n", Cmd, error); SetResultSize(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; @@ -1146,8 +1201,7 @@ void cdrInterrupt(void) { } else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { cdr.CmdInProgress = cdr.Cmd; - CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n", - psxRegs.cycle, cdr.Cmd, Cmd); + CDR_LOG_I("cmd %02x came before %02x finished\n", cdr.Cmd, Cmd); } setIrq(Cmd); @@ -1215,7 +1269,7 @@ static void cdrAttenuate(s16 *buf, int samples, int stereo) static void cdrReadInterruptSetResult(unsigned char result) { if (cdr.Stat) { - CDR_LOG_I("cdrom: %d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n", + CDR_LOG_I("%d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n", cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.CmdInProgress, cdr.Stat); cdr.Irq1Pending = result; @@ -1235,14 +1289,25 @@ static void cdrUpdateTransferBuf(const u8 *buf) CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); CDR_LOG("cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); if (cdr.FifoOffset < 2048 + 12) - CDR_LOG("cdrom: FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); + CDR_LOG("FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); } static void cdrReadInterrupt(void) { u8 *buf = NULL, *hdr; + u8 subqPos[3]; int read_ok; + memcpy(subqPos, cdr.SetSectorPlay, sizeof(subqPos)); + msfiAdd(subqPos, cdr.SubqForwardSectors); + UpdateSubq(subqPos); + if (cdr.SubqForwardSectors < SUBQ_FORWARD_SECTORS) { + cdr.SubqForwardSectors++; + CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); + return; + } + + // note: CdlGetlocL should work as soon as STATUS_READ is indicated SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); read_ok = ReadTrack(cdr.SetSectorPlay); @@ -1253,13 +1318,12 @@ static void cdrReadInterrupt(void) if (!read_ok) { CDR_LOG_I("cdrReadInterrupt() Log: err\n"); - memset(cdr.Transfer, 0, DATA_SIZE); cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR); return; } memcpy(cdr.LocL, buf, 8); - if (!cdr.Irq1Pending) + if (!cdr.Stat && !cdr.Irq1Pending) cdrUpdateTransferBuf(buf); if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA @@ -1295,20 +1359,7 @@ static void cdrReadInterrupt(void) if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4)) cdrReadInterruptSetResult(cdr.StatP); - cdr.SetSectorPlay[2]++; - if (cdr.SetSectorPlay[2] == 75) { - cdr.SetSectorPlay[2] = 0; - cdr.SetSectorPlay[1]++; - if (cdr.SetSectorPlay[1] == 60) { - cdr.SetSectorPlay[1] = 0; - cdr.SetSectorPlay[0]++; - } - } - - if (!cdr.Irq1Pending) { - // update for CdlGetlocP - ReadTrack(cdr.SetSectorPlay); - } + msfiAdd(cdr.SetSectorPlay, 1); CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); } @@ -1375,7 +1426,7 @@ void cdrWrite1(unsigned char rt) { } #ifdef CDR_LOG_CMD_IRQ - SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]); + CDR_LOG_I("CD1 write: %x (%s)", rt, CmdName[rt]); if (cdr.ParamC) { int i; SysPrintf(" Param[%d] = {", cdr.ParamC); @@ -1396,8 +1447,8 @@ void cdrWrite1(unsigned char rt) { CDR_INT(5000); } else { - CDR_LOG_I("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n", - psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress); + CDR_LOG_I("cmd while busy: %02x, prev %02x, busy %02x\n", + rt, cdr.Cmd, cdr.CmdInProgress); if (cdr.CmdInProgress < 0x100) // no pending 2nd response cdr.CmdInProgress = rt; } @@ -1406,12 +1457,12 @@ void cdrWrite1(unsigned char rt) { } unsigned char cdrRead2(void) { - unsigned char ret = 0; + unsigned char ret = cdr.Transfer[0x920]; if (cdr.FifoOffset < cdr.FifoSize) ret = cdr.Transfer[cdr.FifoOffset++]; else - CDR_LOG_I("cdrom: read empty fifo (%d)\n", cdr.FifoSize); + CDR_LOG_I("read empty fifo (%d)\n", cdr.FifoSize); CDR_LOG_IO("cdr r2.dat: %02x\n", ret); return ret; @@ -1458,14 +1509,24 @@ void cdrWrite3(unsigned char rt) { break; // transfer case 1: if (cdr.Stat & rt) { + u32 nextCycle = psxRegs.intCycle[PSXINT_CDR].sCycle + + psxRegs.intCycle[PSXINT_CDR].cycle; + int pending = psxRegs.interrupt & (1 << PSXINT_CDR); #ifdef CDR_LOG_CMD_IRQ - SysPrintf("%u cdrom: ack %02x (w %02x)\n", - psxRegs.cycle, cdr.Stat & rt, rt); + CDR_LOG_I("ack %02x (w=%02x p=%d,%x,%x,%d)\n", cdr.Stat & rt, rt, + !!pending, cdr.CmdInProgress, + cdr.Irq1Pending, nextCycle - psxRegs.cycle); #endif - // note: Croc vs Discworld Noir - if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && - (cdr.CmdInProgress || cdr.Irq1Pending)) - CDR_INT(850); // 711-993 + // note: Croc, Shadow Tower (more) vs Discworld Noir (<993) + if (!pending && (cdr.CmdInProgress || cdr.Irq1Pending)) + { + s32 c = 2048; + if (cdr.CmdInProgress) { + c = 2048 - (psxRegs.cycle - nextCycle); + c = MAX_VALUE(c, 512); + } + CDR_INT(c); + } } cdr.Stat &= ~rt; @@ -1490,7 +1551,7 @@ void cdrWrite3(unsigned char rt) { CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); } else if (rt & 0x80) { - switch (cdr.Mode & 0x30) { + switch (cdr.Mode & (MODE_SIZE_2328|MODE_SIZE_2340)) { case MODE_SIZE_2328: case 0x00: cdr.FifoOffset = 12; @@ -1509,15 +1570,22 @@ void cdrWrite3(unsigned char rt) { } void psxDma3(u32 madr, u32 bcr, u32 chcr) { - u32 cdsize; + u32 cdsize, max_words; int size; u8 *ptr; - CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr); +#if 0 + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x", chcr, madr, bcr); + if (cdr.FifoOffset == 0) { + ptr = cdr.Transfer; + SysPrintf(" %02x:%02x:%02x", ptr[0], ptr[1], ptr[2]); + } + SysPrintf("\n"); +#endif switch (chcr & 0x71000000) { case 0x11000000: - ptr = (u8 *)PSXM(madr); + ptr = getDmaRam(madr, &max_words); if (ptr == INVALID_PTR) { CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); break; @@ -1534,14 +1602,18 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { size = DATA_SIZE - cdr.FifoOffset; if (size > cdsize) size = cdsize; + if (size > max_words * 4) + size = max_words * 4; if (size > 0) { memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size); cdr.FifoOffset += size; - psxCpu->Clear(madr, size / 4); } - if (size < cdsize) + if (size < cdsize) { CDR_LOG_I("cdrom: dma3 %d/%d\n", size, cdsize); + memset(ptr + size, cdr.Transfer[0x920], cdsize - size); + } + psxCpu->Clear(madr, cdsize / 4); CDRDMA_INT((cdsize/4) * 24); @@ -1631,8 +1703,10 @@ int cdrFreeze(void *f, int Mode) { if (Mode == 0) { getCdInfo(); - cdr.FifoOffset = tmp; - cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12; + cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE; + cdr.FifoSize = (cdr.Mode & MODE_SIZE_2340) ? 2340 : 2048 + 12; + if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS) + cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS; // read right sub data tmpp[0] = btoi(cdr.Prev[0]); @@ -1648,8 +1722,6 @@ int cdrFreeze(void *f, int Mode) { Find_CurTrack(cdr.SetSectorPlay); if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); - if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD)) - CDRPLAYREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1); } if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {