u8 unused7;
- u8 DriveState;
+ u8 DriveState; // enum drive_state
u8 FastForward;
u8 FastBackward;
u8 errorRetryhack;
#define SUBQ_FORWARD_SECTORS 2u
enum drive_state {
- DRIVESTATE_STANDBY = 0, // pause, play, read
+ DRIVESTATE_STANDBY = 0, // different from paused
DRIVESTATE_LID_OPEN,
DRIVESTATE_RESCAN_CD,
DRIVESTATE_PREPARE_CD,
DRIVESTATE_STOPPED,
+ DRIVESTATE_PAUSED,
+ DRIVESTATE_PLAY_READ,
+ DRIVESTATE_SEEK,
};
static struct CdrStat stat;
// 02, 12, 10
if (!(cdr.StatP & STATUS_SHELLOPEN)) {
+ StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.StatP |= STATUS_SHELLOPEN;
// IIRC this sometimes doesn't happen on real hw
// (when lots of commands are sent?)
- if (cdr.Reading) {
- StopReading();
- SetResultSize(2);
- cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR;
- cdr.Result[1] = ERROR_SHELLOPEN;
- setIrq(DiskError, 0x1006);
- }
+ SetResultSize(2);
+ cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR;
+ cdr.Result[1] = ERROR_SHELLOPEN;
if (cdr.CmdInProgress) {
psxRegs.interrupt &= ~(1 << PSXINT_CDR);
cdr.CmdInProgress = 0;
- SetResultSize(2);
cdr.Result[0] = cdr.StatP | STATUS_ERROR;
cdr.Result[1] = ERROR_NOTREADY;
- setIrq(DiskError, 0x1007);
}
+ setIrq(DiskError, 0x1006);
set_event(PSXINT_CDRLID, cdReadTime * 30);
break;
StopCdda();
SetPlaySeekRead(cdr.StatP, 0);
+ cdr.DriveState = DRIVESTATE_PAUSED;
}
else if ((cdr.Mode & MODE_REPORT) && !cdr.ReportDelay &&
((cdr.subq.Absolute[2] & 0x0f) == 0 || cdr.FastForward || cdr.FastBackward))
// need this stupidly long penalty or else Spyro2 intro desyncs
// note: if misapplied this breaks MGS cutscenes among other things
- if (cyclesSinceRS > cdReadTime * 50)
+ if (cdr.DriveState == DRIVESTATE_PAUSED && cyclesSinceRS > cdReadTime * 50)
seekTime += cdReadTime * 25;
// Transformers Beast Wars Transmetals does Setloc(x),SeekL,Setloc(x),ReadN
// and then wants some slack time
- else if (cyclesSinceRS < cdReadTime *3/2)
+ else if (cdr.DriveState == DRIVESTATE_PAUSED || cyclesSinceRS < cdReadTime *3/2)
seekTime += cdReadTime;
seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3);
- CDR_LOG("seek: %.2f %.2f (%.2f)\n", (float)seekTime / PSXCLK,
- (float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime);
+ CDR_LOG("seek: %.2f %.2f (%.2f) st %d\n", (float)seekTime / PSXCLK,
+ (float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime,
+ cdr.DriveState);
return seekTime;
}
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)
{
CDR_LOG("CDDA - %02d:%02d:%02d m %02x\n",
cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Mode);
+ cdr.DriveState = DRIVESTATE_PLAY_READ;
SetPlaySeekRead(cdr.StatP, STATUS_PLAY);
if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
CDR_LOG_I("end stop\n");
StopCdda();
SetPlaySeekRead(cdr.StatP, 0);
cdr.TrackChanged = TRUE;
+ cdr.DriveState = DRIVESTATE_PAUSED;
}
else {
CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf);
if (!cdr.IrqStat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
cdrPlayInterrupt_Autopause();
- if (!cdr.Muted && cdr.Play && !Config.Cdda) {
+ if (cdr.Play && !Config.Cdda) {
cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4);
- cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, 0);
}
int read_ok;
u16 not_ready = 0;
u8 IrqStat = Acknowledge;
+ u8 DriveStateOld;
u16 Cmd;
int i;
// BIOS player - set flag again
cdr.Play = TRUE;
+ cdr.DriveState = DRIVESTATE_PLAY_READ;
CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
start_rotating = 1;
error = ERROR_BAD_ARGNUM;
goto set_error;
}
+ cdr.DriveState = DRIVESTATE_STANDBY;
second_resp_time = cdReadTime * 125 / 2;
start_rotating = 1;
break;
cdr.LocL[0] = LOCL_INVALID;
second_resp_time = 0x800;
- if (cdr.DriveState == DRIVESTATE_STANDBY)
+ if (cdr.DriveState != DRIVESTATE_STOPPED)
second_resp_time = cdReadTime * 30 / 2;
cdr.DriveState = DRIVESTATE_STOPPED;
break;
case CdlPause:
+ if (cdr.AdpcmActive) {
+ cdr.AdpcmActive = 0;
+ cdr.Xa.nsamples = 0;
+ SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 1); // flush adpcm
+ }
StopCdda();
StopReading();
second_resp_time = (((cdr.Mode & MODE_SPEED) ? 1 : 2) * 1097107);
}
SetPlaySeekRead(cdr.StatP, 0);
+ DriveStateOld = cdr.DriveState;
+ cdr.DriveState = DRIVESTATE_PAUSED;
+ if (DriveStateOld == DRIVESTATE_SEEK) {
+ // According to Duckstation this fails, but the
+ // exact conditions and effects are not clear.
+ // Moto Racer World Tour seems to rely on this.
+ // For now assume pause works anyway, just errors out.
+ error = ERROR_NOTREADY;
+ goto set_error;
+ }
break;
case CdlPause + CMD_PART2:
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.LocL[0] = LOCL_INVALID;
- cdr.Muted = FALSE;
cdr.Mode = MODE_SIZE_2340; /* This fixes This is Football 2, Pooh's Party lockups */
+ cdr.DriveState = DRIVESTATE_PAUSED;
+ cdr.Muted = FALSE;
+ SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
+ cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle);
second_resp_time = not_ready ? 70000 : 4100000;
start_rotating = 1;
break;
case CdlMute:
cdr.Muted = TRUE;
+ SPU_setCDvol(0, 0, 0, 0, psxRegs.cycle);
break;
case CdlDemute:
cdr.Muted = FALSE;
+ SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
+ cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle);
break;
case CdlSetfilter:
cdr.FilterFile = cdr.Param[0];
cdr.FilterChannel = cdr.Param[1];
+ cdr.FileChannelSelected = 0;
break;
case CdlSetmode:
seekTime = cdrSeekTime(cdr.SetSector);
memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+ cdr.DriveState = DRIVESTATE_SEEK;
/*
Crusaders of Might and Magic = 0.5x-4x
- fix cutscene speech start
if (read_ok && (buf = CDR_getBuffer()))
memcpy(cdr.LocL, buf, 8);
UpdateSubq(cdr.SetSectorPlay);
+ cdr.DriveState = DRIVESTATE_STANDBY;
cdr.TrackChanged = FALSE;
cdr.LastReadSeekCycles = psxRegs.cycle;
break;
cdr.LocL[0] = LOCL_INVALID;
cdr.SubqForwardSectors = 1;
cdr.sectorsRead = 0;
+ cdr.DriveState = DRIVESTATE_SEEK;
cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2;
cycles += seekTime;
#endif
}
-static void cdrAttenuate(s16 *buf, int samples, int stereo)
-{
- int i, l, r;
- int ll = cdr.AttenuatorLeftToLeft;
- int lr = cdr.AttenuatorLeftToRight;
- int rl = cdr.AttenuatorRightToLeft;
- int rr = cdr.AttenuatorRightToRight;
-
- if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
- return;
-
- if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
- return;
-
- if (stereo) {
- for (i = 0; i < samples; i++) {
- l = buf[i * 2];
- r = buf[i * 2 + 1];
- l = (l * ll + r * rl) >> 7;
- r = (r * rr + l * lr) >> 7;
- ssat32_to_16(l);
- ssat32_to_16(r);
- buf[i * 2] = l;
- buf[i * 2 + 1] = r;
- }
- }
- else {
- for (i = 0; i < samples; i++) {
- l = buf[i];
- l = l * (ll + rl) >> 7;
- //r = r * (rr + lr) >> 7;
- ssat32_to_16(l);
- //ssat32_to_16(r);
- buf[i] = l;
- }
- }
-}
-
static void cdrReadInterruptSetResult(unsigned char result)
{
if (cdr.IrqStat) {
int deliver_data = 1;
u8 subqPos[3];
int read_ok;
+ int is_start;
memcpy(subqPos, cdr.SetSectorPlay, sizeof(subqPos));
msfiAdd(subqPos, cdr.SubqForwardSectors);
// note: CdlGetlocL should work as soon as STATUS_READ is indicated
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
+ cdr.DriveState = DRIVESTATE_PLAY_READ;
cdr.sectorsRead++;
read_ok = ReadTrack(cdr.SetSectorPlay);
if (!read_ok) {
CDR_LOG_I("cdrReadInterrupt() Log: err\n");
cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
+ cdr.DriveState = DRIVESTATE_PAUSED; // ?
return;
}
memcpy(cdr.LocL, buf, 8);
if (Config.Xa)
break;
- if (!cdr.Muted && cdr.AdpcmActive) {
- cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
- SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 0);
- }
- // decode next
- cdr.AdpcmActive = !xa_decode_sector(&cdr.Xa, buf + 4, !cdr.AdpcmActive);
+ is_start = !cdr.AdpcmActive;
+ cdr.AdpcmActive = !xa_decode_sector(&cdr.Xa, buf + 4, is_start);
+ if (cdr.AdpcmActive)
+ SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, is_start);
} while (0);
if ((cdr.Mode & MODE_SF) && (subhdr->mode & 0x44) == 0x44) // according to nocash
void cdrWrite3(unsigned char rt) {
const char *rnames[] = { "req", "ifl", "alr", "ava" }; (void)rnames;
+ u8 ll, lr, rl, rr;
CDR_LOG_IO("cdr w3.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
switch (cdr.Ctrl & 3) {
cdr.AttenuatorLeftToRightT = rt;
return;
case 3:
+ if (rt & 0x01)
+ log_unhandled("Mute ADPCM?\n");
if (rt & 0x20) {
- memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
- CDR_LOG("CD-XA Volume: %02x %02x | %02x %02x\n",
- cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
- cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
+ ll = cdr.AttenuatorLeftToLeftT; lr = cdr.AttenuatorLeftToRightT;
+ rl = cdr.AttenuatorRightToLeftT; rr = cdr.AttenuatorRightToRightT;
+ if (ll == cdr.AttenuatorLeftToLeft &&
+ lr == cdr.AttenuatorLeftToRight &&
+ rl == cdr.AttenuatorRightToLeft &&
+ rr == cdr.AttenuatorRightToRight)
+ return;
+ cdr.AttenuatorLeftToLeftT = ll; cdr.AttenuatorLeftToRightT = lr;
+ cdr.AttenuatorRightToLeftT = rl; cdr.AttenuatorRightToRightT = rr;
+ CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", ll, lr, rl, rr);
+ SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle);
}
return;
}
cdr.AttenuatorLeftToRight = 0x00;
cdr.AttenuatorRightToLeft = 0x00;
cdr.AttenuatorRightToRight = 0x80;
+ SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
+ cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle);
getCdInfo();
}
gzfreeze(&tmp, sizeof(tmp));
if (Mode == 0) {
+ u8 ll = 0, lr = 0, rl = 0, rr = 0;
getCdInfo();
cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
}
+ if (!cdr.Muted)
+ ll = cdr.AttenuatorLeftToLeft, lr = cdr.AttenuatorLeftToLeft,
+ rl = cdr.AttenuatorRightToLeft, rr = cdr.AttenuatorRightToRight;
+ SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle);
}
return 0;
notaz.gp2x.de / pcsx_rearmed.git / blobdiff