static void store_sft(INTRST is, SFTREC sft) {
REG16 off;
REG16 seg;
off = LOADINTELWORD(is->r.w.di);
seg = LOADINTELWORD(is->r.w.es);
MEMR_WRITES(seg, off, sft, sizeof(_SFTREC));
}
REG8 lio_gcircle(GLIO lio)
{
GCIRCLE dat;
SINT16 cx;
SINT16 cy;
SINT16 rx;
SINT16 ry;
REG8 pal;
SINT16 d1;
SINT16 d2;
SINT16 d3;
lio_updatedraw(lio);
MEMR_READS(CPU_DS, CPU_BX, &dat, sizeof(dat));
// チェック
if (dat.flag & 0x7f) {
TRACEOUT(("LIO GCIRCLE not support flags: %.2x", dat.flag));
}
cx = (SINT16)LOADINTELWORD(dat.cx);
cy = (SINT16)LOADINTELWORD(dat.cy);
rx = (SINT16)LOADINTELWORD(dat.rx);
ry = (SINT16)LOADINTELWORD(dat.ry);
pal = dat.pal;
if (pal == 0xff) {
pal = lio->work.fgcolor;
}
if (rx != ry) {
TRACEOUT(("LIO GCIRCLE not support ellipse"));
return(LIO_SUCCESS);
}
// 単純な円の描画
d1 = 0;
d2 = ry;
d3 = 0 - ry;
while(d1 <= d2) {
draw4(lio, cx, cy, d1, d2, pal);
draw4(lio, cx, cy, d2, d1, pal);
lio->wait += 8 * (10 + 10 + 10);
d1++;
d3 += (d1 * 2) - 1;
if (d3 >= 0) {
d2--;
d3 -= d2 * 2;
}
}
return(LIO_SUCCESS);
}
static int issec2352(FILEH fh) {
long fpos;
UINT8 buf[2048];
UINT secsize;
UINT fsize;
fpos = (16 * 2352) + 16;
if (file_seek(fh, fpos, FSEEK_SET) != fpos) {
goto sec2352_err;
}
if (file_read(fh, buf, sizeof(buf)) != sizeof(buf)) {
goto sec2352_err;
}
if (memcmp(buf, cd001, 7) != 0) {
goto sec2352_err;
}
secsize = LOADINTELWORD(buf + 128);
if (secsize != 2048) {
goto sec2352_err;
}
fsize = file_getsize(fh);
if ((fsize % 2352) != 0) {
goto sec2352_err;
}
return(fsize / 2352);
sec2352_err:
return(-1);
}
long issec2448(FILEH fh) {
#ifdef CHECK_ISO9660
long fpos;
UINT8 buf[2048];
UINT secsize;
#endif
UINT fsize;
#ifdef CHECK_ISO9660
fpos = (16 * 2448) + 16;
if (file_seek(fh, fpos, FSEEK_SET) != fpos) {
goto sec2448_err;
}
if (file_read(fh, buf, sizeof(buf)) != sizeof(buf)) {
goto sec2448_err;
}
if (memcmp(buf, cd001, 7) != 0) {
goto sec2448_err;
}
secsize = LOADINTELWORD(buf + 128);
if (secsize != 2048) {
goto sec2448_err;
}
#endif
fsize = file_getsize(fh);
if ((fsize % 2448) != 0) {
goto sec2448_err;
}
return(fsize / 2448);
sec2448_err:
return(-1);
}
static void fetch_if4dos(void) {
REG16 off;
REG16 seg;
IF4DOS if4dos;
off = MEMR_READ16(IF4DOSPTR_SEG, IF4DOSPTR_OFF + 0);
seg = MEMR_READ16(IF4DOSPTR_SEG, IF4DOSPTR_OFF + 2);
MEMR_READS(seg, off, &if4dos, sizeof(if4dos));
hostdrv.stat.drive_no = if4dos.drive_no;
hostdrv.stat.dosver_major = if4dos.dosver_major;
hostdrv.stat.dosver_minor = if4dos.dosver_minor;
hostdrv.stat.sda_off = LOADINTELWORD(if4dos.sda_off);
hostdrv.stat.sda_seg = LOADINTELWORD(if4dos.sda_seg);
TRACEOUT(("hostdrv:drive_no = %d", if4dos.drive_no));
TRACEOUT(("hostdrv:dosver = %d.%.2d", if4dos.dosver_major, if4dos.dosver_minor));
TRACEOUT(("hostdrv.sda = %.4x:%.4x", hostdrv.stat.sda_seg, hostdrv.stat.sda_off));
}
static void fetch_sda_currcds(SDACDS sc) {
REG16 off;
REG16 seg;
if (hostdrv.stat.dosver_major == 3) {
MEMR_READS(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
&sc->ver3.sda, sizeof(sc->ver3.sda));
off = LOADINTELWORD(sc->ver3.sda.cdsptr.off);
seg = LOADINTELWORD(sc->ver3.sda.cdsptr.seg);
MEMR_READS(seg, off, &sc->ver3.cds, sizeof(sc->ver3.cds));
}
else {
MEMR_READS(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
&sc->ver4.sda, sizeof(sc->ver4.sda));
off = LOADINTELWORD(sc->ver4.sda.cdsptr.off);
seg = LOADINTELWORD(sc->ver4.sda.cdsptr.seg);
MEMR_READS(seg, off, &sc->ver4.cds, sizeof(sc->ver4.cds));
}
}
void savefile_cnvdate(SAVEDATE sd, const void *st) {
sd->year = LOADINTELWORD(((_SYSTIME *)st)->year);
sd->month = LOADINTELWORD(((_SYSTIME *)st)->month);
sd->day = LOADINTELWORD(((_SYSTIME *)st)->day);
sd->hour = LOADINTELWORD(((_SYSTIME *)st)->hour);
sd->min = LOADINTELWORD(((_SYSTIME *)st)->minute);
sd->sec = LOADINTELWORD(((_SYSTIME *)st)->second);
}
void adpcm_update(ADPCM ad) {
UINT32 addr;
if (adpcmcfg.rate) {
ad->base = ADTIMING * (OPNA_CLOCK / 72) / adpcmcfg.rate;
}
addr = LOADINTELWORD(ad->reg.delta);
addr = (addr * ad->base) >> 16;
if (addr < 0x80) {
addr = 0x80;
}
ad->step = addr;
ad->pertim = (1 << (ADTIMING_BIT * 2)) / addr;
ad->level = (ad->reg.level * adpcmcfg.vol) >> 4;
}
long issec(FILEH fh, _CDTRK *trk, UINT trks) {
#ifdef CHECK_ISO9660
long fpos;
UINT8 buf[2048];
UINT secsize;
#endif
UINT i;
// UINT fsize;
INT64 fsize;
long total;
total = 0;
#ifdef CHECK_ISO9660
fpos = 16 * trk[0].sector_size;
if (trk[0].sector_size != 2048) {
fpos += 16;
}
if (file_seek(fh, fpos, FSEEK_SET) != fpos) {
goto sec_err;
}
if (file_read(fh, buf, sizeof(buf)) != sizeof(buf)) {
goto sec_err;
}
if (memcmp(buf, cd001, 7) != 0) {
goto sec_err;
}
secsize = LOADINTELWORD(buf + 128);
if (secsize != 2048) {
goto sec_err;
}
#endif
if (trks == 1) {
trk[0].sector_size = 2048;
trk[0].str_sec = 0;
total = issec2048(fh);
if (total < 0) {
trk[0].sector_size = 2352;
total = issec2352(fh);
}
if (total < 0) {
trk[0].sector_size = 2448;
total = issec2448(fh);
}
if (total < 0) {
return(-1);
}
else {
trk[0].end_sec = total - 1;
trk[0].sectors = total;
return(total);
}
}
// fsize = file_getsize(fh);
fsize = file_getsizei64(fh);
if (trk[0].pos0 == 0) {
trk[0].str_sec = trk[0].pos;
}
else {
trk[0].str_sec = trk[0].pos0;
}
for (i = 1; i < trks; i++) {
if (trk[i].pos0 == 0) {
trk[i].str_sec = trk[i].pos;
}
else {
trk[i].str_sec = trk[i].pos0;
}
trk[i-1].end_sec = trk[i].str_sec - 1;
trk[i-1].sectors = trk[i-1].end_sec - trk[i-1].str_sec + 1;
total += trk[i-1].sectors;
fsize -= trk[i-1].sectors * trk[i-1].sector_size;
}
if (fsize % trk[trks-1].sector_size != 0) {
return(-1);
}
if (trk[trks-1].pos0 == 0) {
trk[trks-1].str_sec = trk[trks-1].pos;
}
else {
trk[trks-1].str_sec = trk[trks-1].pos0;
}
trk[trks-1].end_sec = trk[trks-1].str_sec + (fsize / trk[trks-1].sector_size);
trk[trks-1].sectors = trk[trks-1].end_sec - trk[trks-1].str_sec + 1;
total += trk[trks-1].sectors;
return(total);
#ifdef CHECK_ISO9660
sec_err:
return(-1);
#endif
}
void bios_initialize(void) {
BOOL biosrom;
OEMCHAR path[MAX_PATH];
FILEH fh;
UINT i;
UINT32 tmp;
UINT pos;
biosrom = FALSE;
getbiospath(path, str_biosrom, NELEMENTS(path));
fh = file_open_rb(path);
if (fh != FILEH_INVALID) {
biosrom = (file_read(fh, mem + 0x0e8000, 0x18000) == 0x18000);
file_close(fh);
}
if (biosrom) {
TRACEOUT(("load bios.rom"));
pccore.rom |= PCROM_BIOS;
// PnP BIOSを潰す
for (i=0; i<0x10000; i+=0x10) {
tmp = LOADINTELDWORD(mem + 0xf0000 + i);
if (tmp == 0x506e5024) {
TRACEOUT(("found PnP BIOS at %.5x", 0xf0000 + i));
mem[0xf0000 + i] = 0x6e;
mem[0xf0002 + i] = 0x24;
break;
}
}
}
else {
CopyMemory(mem + 0x0e8000, nosyscode, sizeof(nosyscode));
if ((!biosrom) && (!(pccore.model & PCMODEL_EPSON))) {
CopyMemory(mem + 0xe8dd8, neccheck, 0x25);
pos = LOADINTELWORD(itfrom + 2);
CopyMemory(mem + 0xf538e, itfrom + pos, 0x27);
}
setbiosseed(mem + 0x0e8000, 0x10000, 0xb1f0);
}
#if defined(SUPPORT_PC9821)
getbiospath(path, OEMTEXT("bios9821.rom"), sizeof(path));
fh = file_open_rb(path);
if (fh != FILEH_INVALID) {
if (file_read(fh, mem + 0x0d8000, 0x2000) == 0x2000) {
// IDE BIOSを潰す
TRACEOUT(("load bios9821.rom"));
STOREINTELWORD(mem + 0x0d8009, 0);
}
file_close(fh);
}
#if defined(BIOS_SIMULATE)
mem[0xf8e80] = 0x98;
mem[0xf8e81] = 0x21;
mem[0xf8e82] = 0x1f;
mem[0xf8e83] = 0x20; // Model Number?
mem[0xf8e84] = 0x2c;
mem[0xf8e85] = 0xb0;
// mem[0xf8eaf] = 0x21; // <- これって何だっけ？
#endif
#endif
#if defined(BIOS_SIMULATE)
CopyMemory(mem + BIOS_BASE, biosfd80, sizeof(biosfd80));
if (!biosrom) {
lio_initialize();
}
for (i=0; i<8; i+=2) {
STOREINTELWORD(mem + 0xfd800 + 0x1aaf + i, 0x1ab7);
STOREINTELWORD(mem + 0xfd800 + 0x1ad7 + i, 0x1adf);
STOREINTELWORD(mem + 0xfd800 + 0x2361 + i, 0x1980);
}
CopyMemory(mem + 0xfd800 + 0x1ab7, fdfmt2hd, sizeof(fdfmt2hd));
CopyMemory(mem + 0xfd800 + 0x1adf, fdfmt2dd, sizeof(fdfmt2dd));
CopyMemory(mem + 0xfd800 + 0x1980, fdfmt144, sizeof(fdfmt144));
SETBIOSMEM16(0xfffe8, 0xcb90);
SETBIOSMEM16(0xfffec, 0xcb90);
mem[0xffff0] = 0xea;
STOREINTELDWORD(mem + 0xffff1, 0xfd800000);
CopyMemory(mem + 0x0fd800 + 0x0e00, keytable[0], 0x300);
CopyMemory(mem + ITF_ADRS, itfrom, sizeof(itfrom));
mem[ITF_ADRS + 0x7ff0] = 0xea;
STOREINTELDWORD(mem + ITF_ADRS + 0x7ff1, 0xf8000000);
if (pccore.model & PCMODEL_EPSON) {
mem[ITF_ADRS + 0x7ff1] = 0x04;
}
else if ((pccore.model & PCMODELMASK) == PCMODEL_VM) {
mem[ITF_ADRS + 0x7ff1] = 0x08;
}
setbiosseed(mem + 0x0f8000, 0x08000, 0x7ffe);
#else
fh = file_open_c("itf.rom");
if (fh != FILEH_INVALID) {
file_read(fh, mem + ITF_ADRS, 0x8000);
file_close(fh);
TRACEOUT(("load itf.rom"));
}
#endif
CopyMemory(mem + 0x1c0000, mem + ITF_ADRS, 0x08000);
CopyMemory(mem + 0x1e8000, mem + 0x0e8000, 0x10000);
}
void soundmng_pcmload(UINT num, const OEMCHAR *filename, UINT type) {
EXTROMH erh;
RIFF_HEADER riff;
BOOL head;
WAVE_HEADER whead;
UINT size;
WAVE_INFOS info;
PCMWAVEFORMAT pcmwf;
DSBUFFERDESC dsbdesc;
LPDIRECTSOUNDBUFFER dsbuf;
HRESULT hr;
LPBYTE blockptr1;
LPBYTE blockptr2;
DWORD blocksize1;
DWORD blocksize2;
if ((pDSound == NULL) || (num >= SOUND_MAXPCM)) {
goto smpl_err1;
}
erh = extromio_open(filename, type);
if (erh == NULL) {
goto smpl_err1;
}
if ((extromio_read(erh, &riff, sizeof(riff)) != sizeof(riff)) ||
(riff.sig != WAVE_SIG('R','I','F','F')) ||
(riff.fmt != WAVE_SIG('W','A','V','E'))) {
goto smpl_err2;
}
head = FALSE;
while(1) {
if (extromio_read(erh, &whead, sizeof(whead)) != sizeof(whead)) {
goto smpl_err2;
}
size = LOADINTELDWORD(whead.size);
if (whead.sig == WAVE_SIG('f','m','t',' ')) {
if (size >= sizeof(info)) {
if (extromio_read(erh, &info, sizeof(info)) != sizeof(info)) {
goto smpl_err2;
}
size -= sizeof(info);
head = TRUE;
}
}
else if (whead.sig == WAVE_SIG('d','a','t','a')) {
break;
}
if (size) {
extromio_seek(erh, size, ERSEEK_CUR);
}
}
if (!head) {
goto smpl_err2;
}
ZeroMemory(&pcmwf, sizeof(PCMWAVEFORMAT));
pcmwf.wf.wFormatTag = LOADINTELWORD(info.format);
if (pcmwf.wf.wFormatTag != 1) {
goto smpl_err2;
}
pcmwf.wf.nChannels = LOADINTELWORD(info.channel);
pcmwf.wf.nSamplesPerSec = LOADINTELDWORD(info.rate);
pcmwf.wBitsPerSample = LOADINTELWORD(info.bit);
pcmwf.wf.nBlockAlign = LOADINTELWORD(info.block);
pcmwf.wf.nAvgBytesPerSec = LOADINTELDWORD(info.rps);
ZeroMemory(&dsbdesc, sizeof(DSBUFFERDESC));
dsbdesc.dwSize = DSBUFFERDESC_SIZE;
dsbdesc.dwFlags = DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME |
DSBCAPS_CTRLFREQUENCY | DSBCAPS_STATIC |
DSBCAPS_STICKYFOCUS | DSBCAPS_GETCURRENTPOSITION2;
dsbdesc.dwBufferBytes = size;
dsbdesc.lpwfxFormat = (LPWAVEFORMATEX)&pcmwf;
if (FAILED(pDSound->CreateSoundBuffer(&dsbdesc, &dsbuf, NULL))) {
goto smpl_err2;
}
hr = dsbuf->Lock(0, size, (LPVOID *)&blockptr1, &blocksize1,
(LPVOID *)&blockptr2, &blocksize2, 0);
if (hr == DSERR_BUFFERLOST) {
dsbuf->Restore();
hr = dsbuf->Lock(0, size, (LPVOID *)&blockptr1, &blocksize1,
(LPVOID *)&blockptr2, &blocksize2, 0);
}
if (SUCCEEDED(hr)) {
extromio_read(erh, blockptr1, blocksize1);
if ((blockptr2) && (blocksize2)) {
extromio_read(erh, blockptr2, blocksize2);
}
dsbuf->Unlock(blockptr1, blocksize1, blockptr2, blocksize2);
pDSwave3[num] = dsbuf;
}
else {
dsbuf->Release();
}
smpl_err2:
extromio_close(erh);
smpl_err1:
return;
}
BRESULT sxsihdd_open(SXSIDEV sxsi, const OEMCHAR *fname) {
FILEH fh;
const OEMCHAR *ext;
REG8 iftype;
long totals;
UINT32 headersize;
UINT32 surfaces;
UINT32 cylinders;
UINT32 sectors;
UINT32 size;
fh = file_open(fname);
if (fh == FILEH_INVALID) {
goto sxsiope_err1;
}
ext = file_getext(fname);
iftype = sxsi->drv & SXSIDRV_IFMASK;
if ((iftype == SXSIDRV_SASI) && (!file_cmpname(ext, str_thd))) {
THDHDR thd; // T98 HDD (IDE)
if (file_read(fh, &thd, sizeof(thd)) != sizeof(thd)) {
goto sxsiope_err2;
}
headersize = 256;
surfaces = 8;
cylinders = LOADINTELWORD(thd.cylinders);
sectors = 33;
size = 256;
totals = cylinders * sectors * surfaces;
}
else if ((iftype == SXSIDRV_SASI) && (!file_cmpname(ext, str_nhd))) {
NHDHDR nhd; // T98Next HDD (IDE)
if ((file_read(fh, &nhd, sizeof(nhd)) != sizeof(nhd)) ||
(memcmp(nhd.sig, sig_nhd, 15))) {
goto sxsiope_err2;
}
headersize = LOADINTELDWORD(nhd.headersize);
surfaces = LOADINTELWORD(nhd.surfaces);
cylinders = LOADINTELDWORD(nhd.cylinders);
sectors = LOADINTELWORD(nhd.sectors);
size = LOADINTELWORD(nhd.sectorsize);
totals = cylinders * sectors * surfaces;
}
else if ((iftype == SXSIDRV_SASI) && (!file_cmpname(ext, str_hdi))) {
HDIHDR hdi; // ANEX86 HDD (SASI) thanx Mamiya
if (file_read(fh, &hdi, sizeof(hdi)) != sizeof(hdi)) {
goto sxsiope_err2;
}
headersize = LOADINTELDWORD(hdi.headersize);
surfaces = LOADINTELDWORD(hdi.surfaces);
cylinders = LOADINTELDWORD(hdi.cylinders);
sectors = LOADINTELDWORD(hdi.sectors);
size = LOADINTELDWORD(hdi.sectorsize);
totals = cylinders * sectors * surfaces;
}
else if ((iftype == SXSIDRV_SCSI) && (!file_cmpname(ext, str_hdd))) {
VHDHDR vhd; // Virtual98 HDD (SCSI)
if ((file_read(fh, &vhd, sizeof(vhd)) != sizeof(vhd)) ||
(memcmp(vhd.sig, sig_vhd, 5))) {
goto sxsiope_err2;
}
headersize = sizeof(vhd);
surfaces = vhd.surfaces;
cylinders = LOADINTELWORD(vhd.cylinders);
sectors = vhd.sectors;
size = LOADINTELWORD(vhd.sectorsize);
totals = (SINT32)LOADINTELDWORD(vhd.totals);
}
else {
goto sxsiope_err2;
}
// フォーマット確認〜
if ((surfaces == 0) || (surfaces >= 256) ||
(cylinders == 0) || (cylinders >= 65536) ||
(sectors == 0) || (sectors >= 256) ||
(size == 0) || ((size & (size - 1)) != 0)) {
goto sxsiope_err2;
}
if (iftype == SXSIDRV_SCSI) {
if (!(size & 0x700)) { // not 256,512,1024
goto sxsiope_err2;
}
}
sxsi->reopen = hdd_reopen;
sxsi->read = hdd_read;
sxsi->write = hdd_write;
sxsi->format = hdd_format;
sxsi->close = hdd_close;
sxsi->hdl = (INTPTR)fh;
sxsi->totals = totals;
sxsi->cylinders = (UINT16)cylinders;
sxsi->size = (UINT16)size;
sxsi->sectors = (UINT8)sectors;
sxsi->surfaces = (UINT8)surfaces;
sxsi->headersize = headersize;
sxsi->mediatype = gethddtype(sxsi);
return(SUCCESS);
sxsiope_err2:
file_close(fh);
sxsiope_err1:
return(FAILURE);
}
void adpcm_setreg(ADPCM ad, UINT reg, REG8 value) {
UINT32 addr;
sound_sync();
((UINT8 *)(&ad->reg))[reg] = value;
switch(reg) {
case 0x00: // control1
if ((value & 0x80) && (!ad->play)) {
ad->play = 0x20;
ad->pos = ad->start;
ad->samp = 0;
ad->delta = 127;
ad->remain = 0;
}
if (value & 1) {
ad->play = 0;
}
break;
case 0x01: // control2
break;
case 0x02: case 0x03: // start address
addr = (LOADINTELWORD(ad->reg.start)) << 5;
ad->pos = addr;
ad->start = addr;
break;
case 0x04: case 0x05: // stop address
addr = (LOADINTELWORD(ad->reg.stop) + 1) << 5;
ad->stop = addr;
break;
case 0x08: // data
if ((ad->reg.ctrl1 & 0x60) == 0x60) {
adpcm_datawrite(ad, value);
}
break;
case 0x09: case 0x0a: // delta
addr = LOADINTELWORD(ad->reg.delta);
addr = (addr * ad->base) >> 16;
if (addr < 0x80) {
addr = 0x80;
}
ad->step = addr;
ad->pertim = (1 << (ADTIMING_BIT * 2)) / addr;
break;
case 0x0b: // level
ad->level = (value * adpcmcfg.vol) >> 4;
break;
case 0x0c: case 0x0d: // limit address
addr = (LOADINTELWORD(ad->reg.limit) + 1) << 5;
ad->limit = addr;
break;
case 0x10: // flag
if (value & 0x80) {
ad->status = 0;
}
else {
ad->mask = ~(value & 0x1f);
}
break;
}
}
void psggen_setreg(PSGGEN psg, REG8 reg, REG8 value) {
UINT freq;
UINT ch;
if (reg >= 14) {
return;
}
sound_sync();
((UINT8 *)&psg->reg)[reg] = value;
switch(reg) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
ch = reg >> 1;
freq = LOADINTELWORD(psg->reg.tune[ch]) & 0xfff;
if (freq > 9) {
psg->tone[ch].freq = (psggencfg.base / freq) << PSGFREQPADBIT;
}
else {
psg->tone[ch].freq = 0;
psg->tone[ch].count = 0; // としておかないとノイズ出ない
}
break;
case 6:
freq = value & 0x1f;
if (freq == 0) {
freq = 1;
}
psg->noise.freq = psggencfg.base / freq;
psg->noise.freq <<= PSGFREQPADBIT;
break;
case 7:
// keydisp_psgmix(psg);
psg->mixer = ~value;
psg->puchicount = psggencfg.puchidec;
break;
case 8:
case 9:
case 10:
ch = reg - 8;
// keydisp_psgvol(psg, (UINT8)ch);
if (value & 0x10) {
psg->tone[ch].pvol = &psg->evol;
}
else {
psg->tone[ch].pvol = psggencfg.volume + (value & 15);
}
psg->tone[ch].puchi = psggencfg.puchidec;
psg->puchicount = psggencfg.puchidec;
break;
case 11:
case 12:
freq = LOADINTELWORD(psg->reg.envtime);
freq = psggencfg.rate * freq / 125000;
if (freq == 0) {
freq = 1;
}
psg->envmax = freq;
break;
case 13:
psg->envmode = psgenv_pat[value & 0x0f];
psg->envvolcnt = 16;
psg->envcnt = 0;
break;
}
}
void psggen_setreg(PSGGEN psg, UINT reg, REG8 value) {
UINT ch;
UINT freq;
reg = reg & 15;
if (reg < 14) {
sound_sync();
}
((UINT8 *)&psg->reg)[reg] = value;
switch(reg) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
ch = reg >> 1;
freq = LOADINTELWORD(psg->reg.tune[ch]) & 0xfff;
if (freq > 9) {
psg->tone[ch].freq = (psggencfg.base / freq) << PSGFREQPADBIT;
}
else {
psg->tone[ch].freq = 0;
}
break;
case 6:
freq = value & 0x1f;
if (freq == 0) {
freq = 1;
}
psg->noise.freq = (psggencfg.base / freq) << PSGFREQPADBIT;
break;
case 7:
psg->mixer = ~value;
psg->puchicount = psggencfg.puchidec;
// TRACEOUT(("psg %x 7 %d", (long)psg, value));
break;
case 8:
case 9:
case 10:
ch = reg - 8;
if (value & 0x10) {
psg->tone[ch].pvol = &psg->evol;
}
else {
psg->tone[ch].pvol = psggencfg.volume + (value & 15);
}
psg->tone[ch].puchi = psggencfg.puchidec;
psg->puchicount = psggencfg.puchidec;
// TRACEOUT(("psg %x %x %d", (long)psg, reg, value));
break;
case 11:
case 12:
freq = LOADINTELWORD(psg->reg.envtime);
freq = psggencfg.rate * freq / 125000;
if (freq == 0) {
freq = 1;
}
psg->envmax = freq;
break;
case 13:
psg->envmode = psgenv_pat[value & 0x0f];
psg->envvolcnt = 16;
psg->envcnt = 1;
break;
}
}
REG16 MEMCALL memvgaf_rd16(UINT32 address) {
address = address & 0x7ffff;
return(LOADINTELWORD(vramex + address));
}
BOOL dispsync_renewalvertical(void) {
UINT text_vbp;
UINT grph_vbp;
UINT textymax;
UINT grphymax;
UINT scrnymax;
text_vbp = gdc.m.para[GDC_SYNC + 7] >> 2;
grph_vbp = gdc.s.para[GDC_SYNC + 7] >> 2;
if (text_vbp >= grph_vbp) {
text_vbp -= grph_vbp;
grph_vbp = 0;
}
else {
grph_vbp -= text_vbp;
text_vbp = 0;
}
textymax = LOADINTELWORD(gdc.m.para + GDC_SYNC + 6);
textymax = ((textymax - 1) & 0x3ff) + 1;
textymax += text_vbp;
grphymax = LOADINTELWORD(gdc.s.para + GDC_SYNC + 6);
grphymax = ((grphymax - 1) & 0x3ff) + 1;
grphymax += grph_vbp;
#if defined(SUPPORT_CRT15KHZ)
if (gdc.crt15khz & 2) {
textymax *= 2;
grphymax *= 2;
}
#endif
if (textymax > SURFACE_HEIGHT) {
textymax = SURFACE_HEIGHT;
}
if (grphymax > SURFACE_HEIGHT) {
grphymax = SURFACE_HEIGHT;
}
if ((dsync.text_vbp == text_vbp) && (dsync.grph_vbp == grph_vbp) &&
(dsync.textymax == textymax) && (dsync.grphymax == grphymax)) {
return(FALSE);
}
dsync.text_vbp = text_vbp;
dsync.grph_vbp = grph_vbp;
dsync.textymax = textymax;
dsync.grphymax = grphymax;
scrnymax = max(grphymax, textymax);
scrnymax = (scrnymax + 7) & (~7);
if (dsync.scrnymax != scrnymax) {
dsync.scrnymax = scrnymax;
scrnmng_setheight(0, scrnymax);
}
dsync.textvad = text_vbp * 640;
dsync.grphvad = grph_vbp * 640;
if (text_vbp) {
ZeroMemory(np2_tram, text_vbp * 640);
}
if (scrnymax - textymax) {
ZeroMemory(np2_tram + textymax * 640, (scrnymax - textymax) * 640);
}
if (grph_vbp) {
ZeroMemory(np2_vram[0], grph_vbp * 640);
ZeroMemory(np2_vram[1], grph_vbp * 640);
}
if (scrnymax - grphymax) {
ZeroMemory(np2_vram[0] + grphymax * 640, (scrnymax - grphymax) * 640);
ZeroMemory(np2_vram[1] + grphymax * 640, (scrnymax - grphymax) * 640);
}
return(TRUE);
}
static UINT midiwrite(COMMNG self, UINT8 data) {
CMMIDI midi;
MIDICH mch;
midi = (CMMIDI)(self + 1);
switch(data) {
case MIDI_TIMING:
case MIDI_START:
case MIDI_CONTINUE:
case MIDI_STOP:
case MIDI_ACTIVESENSE:
case MIDI_SYSTEMRESET:
return(1);
}
if (midi->midictrl == MIDICTRL_READY) {
if (data & 0x80) {
midi->mpos = 0;
switch(data & 0xf0) {
case 0xc0:
case 0xd0:
midi->midictrl = MIDICTRL_2BYTES;
break;
case 0x80:
case 0x90:
case 0xa0:
case 0xb0:
case 0xe0:
midi->midictrl = MIDICTRL_3BYTES;
midi->midilast = data;
break;
default:
switch(data) {
case MIDI_EXCLUSIVE:
midi->midictrl = MIDICTRL_EXCLUSIVE;
break;
case MIDI_TIMECODE:
midi->midictrl = MIDICTRL_TIMECODE;
break;
case MIDI_SONGPOS:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 3;
break;
case MIDI_SONGSELECT:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 2;
break;
case MIDI_TUNEREQUEST:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 1;
break;
// case MIDI_EOX:
default:
return(1);
}
break;
}
}
else { // Key-onのみな気がしたんだけど忘れた…
// running status
midi->buffer[0] = midi->midilast;
midi->mpos = 1;
midi->midictrl = MIDICTRL_3BYTES;
}
}
midi->buffer[midi->mpos] = data;
midi->mpos++;
switch(midi->midictrl) {
case MIDICTRL_2BYTES:
if (midi->mpos >= 2) {
midi->buffer[1] &= 0x7f;
mch = midi->mch + (midi->buffer[0] & 0xf);
switch(midi->buffer[0] & 0xf0) {
case 0xa0:
mch->press = midi->buffer[1];
break;
case 0xc0:
mch->prog = midi->buffer[1];
break;
}
keydisp_midi(midi->buffer);
sound_sync();
midiout_shortmsg(midi->midihdl, MIDIOUTS2(midi->buffer));
midi->midictrl = MIDICTRL_READY;
return(2);
}
break;
case MIDICTRL_3BYTES:
if (midi->mpos >= 3) {
midi->buffer[1] &= 0x7f;
midi->buffer[2] &= 0x7f;
mch = midi->mch + (midi->buffer[0] & 0xf);
switch(midi->buffer[0] & 0xf0) {
case 0xb0:
if (midi->buffer[1] == 123) {
mch->press = 0;
mch->bend = 0x4000;
mch->ctrl[1+1] = 0; // Modulation
mch->ctrl[5+1] = 127; // Explession
mch->ctrl[6+1] = 0; // Hold
mch->ctrl[7+1] = 0; // Portament
mch->ctrl[8+1] = 0; // Sostenute
mch->ctrl[9+1] = 0; // Soft
}
else {
mch->ctrl[midictrlindex[midi->buffer[1]]]
= midi->buffer[2];
}
break;
case 0xe0:
mch->bend = LOADINTELWORD(midi->buffer + 1);
break;
}
keydisp_midi(midi->buffer);
sound_sync();
midiout_shortmsg(midi->midihdl, MIDIOUTS3(midi->buffer));
midi->midictrl = MIDICTRL_READY;
return(3);
}
break;
case MIDICTRL_EXCLUSIVE:
if (data == MIDI_EOX) {
midiout_longmsg(midi->midihdl, midi->buffer, midi->mpos);
midi->midictrl = MIDICTRL_READY;
return(midi->mpos);
}
else if (midi->mpos >= MIDI_BUFFER) { // おーばーふろー
midi->midictrl = MIDICTRL_READY;
}
break;
case MIDICTRL_TIMECODE:
if (midi->mpos >= 2) {
if ((data == 0x7e) || (data == 0x7f)) {
// exclusiveと同じでいい筈…
midi->midictrl = MIDICTRL_EXCLUSIVE;
}
else {
midi->midictrl = MIDICTRL_READY;
return(2);
}
}
break;
case MIDICTRL_SYSTEM:
if (midi->mpos >= midi->midisyscnt) {
midi->midictrl = MIDICTRL_READY;
return(midi->midisyscnt);
}
break;
}
return(0);
}
static UINT
midiwrite(COMMNG self, UINT8 data)
{
CMMIDI midi;
MIDICH mch;
int type;
midi = (CMMIDI)(self + 1);
switch (data) {
case MIDI_TIMING:
case MIDI_START:
case MIDI_CONTINUE:
case MIDI_STOP:
case MIDI_ACTIVESENSE:
case MIDI_SYSTEMRESET:
return 1;
}
if (midi->midictrl == MIDICTRL_READY) {
if (data & 0x80) {
midi->mpos = 0;
switch (data & 0xf0) {
case 0xc0:
case 0xd0:
midi->midictrl = MIDICTRL_2BYTES;
break;
case 0x80:
case 0x90:
case 0xa0:
case 0xb0:
case 0xe0:
midi->midictrl = MIDICTRL_3BYTES;
midi->midilast = data;
break;
default:
switch (data) {
case MIDI_EXCLUSIVE:
midi->midictrl = MIDICTRL_EXCLUSIVE;
break;
case MIDI_TIMECODE:
midi->midictrl = MIDICTRL_TIMECODE;
break;
case MIDI_SONGPOS:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 3;
break;
case MIDI_SONGSELECT:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 2;
break;
case MIDI_TUNEREQUEST:
midi->midictrl = MIDICTRL_SYSTEM;
midi->midisyscnt = 1;
break;
#if 0
case MIDI_EOX:
#endif
default:
return(1);
}
break;
}
} else { /* Key-onのみな気がしたんだけど忘れた… */
/* running status */
midi->buffer[0] = midi->midilast;
midi->mpos = 1;
midi->midictrl = MIDICTRL_3BYTES;
}
}
midi->buffer[midi->mpos] = data;
midi->mpos++;
switch (midi->midictrl) {
case MIDICTRL_2BYTES:
if (midi->mpos >= 2) {
midi->buffer[1] &= 0x7f;
mch = midi->mch + (midi->buffer[0] & 0xf);
switch (midi->buffer[0] & 0xf0) {
case 0xa0:
mch->press = midi->buffer[1];
break;
case 0xc0:
if (midi->def_en) {
type = midi->def.ch[midi->buffer[0] & 0x0f];
if (type < MIMPI_RHYTHM) {
midi->buffer[1] = midi->def.map[type][midi->buffer[1]];
}
}
mch->prog = midi->buffer[1];
break;
}
keydisp_midi(midi->buffer);
(*midi->outfn)(midi, MIDIOUTS2(midi->buffer), 2);
midi->midictrl = MIDICTRL_READY;
return 2;
}
break;
case MIDICTRL_3BYTES:
if (midi->mpos >= 3) {
midi->buffer[1] &= 0x7f;
midi->buffer[2] &= 0x7f;
mch = midi->mch + (midi->buffer[0] & 0xf);
switch (midi->buffer[0] & 0xf0) {
case 0xb0:
if (midi->buffer[1] == 123) {
mch->press = 0;
mch->bend = 0x4000;
mch->ctrl[1+1] = 0; // Modulation
mch->ctrl[5+1] = 127; // Explession
mch->ctrl[6+1] = 0; // Hold
mch->ctrl[7+1] = 0; // Portament
mch->ctrl[8+1] = 0; // Sostenute
mch->ctrl[9+1] = 0; // Soft
} else {
mch->ctrl[midictrlindex[midi->buffer[1]]] = midi->buffer[2];
}
break;
case 0xe0:
mch->bend = LOADINTELWORD(midi->buffer + 1);
break;
}
keydisp_midi(midi->buffer);
(*midi->outfn)(midi, MIDIOUTS3(midi->buffer), 3);
midi->midictrl = MIDICTRL_READY;
return 3;
}
break;
case MIDICTRL_EXCLUSIVE:
if (data == MIDI_EOX) {
if (midi->opened & CMMIDI_MIDIOUT) {
waitlastexclusiveout(midi);
sendexclusive(midi, midi->buffer, midi->mpos);
}
#if defined(VERMOUTH_LIB)
else if (midi->opened & CMMIDI_VERMOUTH) {
midiout_longmsg(midi->vermouth, midi->buffer, midi->mpos);
}
#endif
midi->midictrl = MIDICTRL_READY;
return midi->mpos;
} else if (midi->mpos >= MIDI_BUFFER) { // おーばーふろー
midi->midictrl = MIDICTRL_READY;
}
break;
case MIDICTRL_TIMECODE:
if (midi->mpos >= 2) {
if ((data == 0x7e) || (data == 0x7f)) {
// exclusiveと同じでいい筈…
midi->midictrl = MIDICTRL_EXCLUSIVE;
} else {
midi->midictrl = MIDICTRL_READY;
return 2;
}
}
break;
case MIDICTRL_SYSTEM:
if (midi->mpos >= midi->midisyscnt) {
midi->midictrl = MIDICTRL_READY;
return midi->midisyscnt;
}
break;
}
return 0;
}