static BOOL readsysflag(SAVEHDL hdl, UINT pos, UINT size) {
SAVEISF isf;
SAVEDATA dat;
BOOL r = FAILURE;
isf = (SAVEISF)(hdl + 1);
dat = saveread(isf, isf->gamesaves);
if (dat == NULL) {
return(FAILURE);
}
if (dat->size > 4) {
BYTE *ptr;
BYTE bit;
BYTE cnt;
size = min(size, LOADINTELDWORD(dat->ptr));
size = min(size, (UINT)(dat->size - 4) * 8);
ptr = dat->ptr + 4;
bit = 0;
cnt = 0;
while(size--) {
if (!cnt) {
bit = *ptr++;
cnt = 8;
}
scr_flagop(pos++, (BYTE)(bit & 1));
bit >>= 1;
cnt--;
}
r = SUCCESS;
}
BRESULT cmndraw_bmp4inf(CMNBMP *bmp, const void *ptr) {
const BMPFILE *bf;
const BMPINFO *bi;
const UINT8 *palptr;
BMPDATA inf;
UINT8 *src;
int bmpalign;
UINT pals;
UINT c;
if ((bmp == NULL) || (ptr == NULL)) {
return(FAILURE);
}
bf = (BMPFILE *)ptr;
bi = (BMPINFO *)(bf + 1);
palptr = (UINT8 *)(bi + 1);
if (((bf->bfType[0] != 'B') && (bf->bfType[1] != 'M')) ||
(bmpdata_getinfo(bi, &inf) != SUCCESS) || (inf.bpp != 4)) {
return(FAILURE);
}
pals = min(LOADINTELDWORD(bi->biClrUsed), 16);
src = (UINT8 *)bf + (LOADINTELDWORD(bf->bfOffBits));
bmpalign = bmpdata_getalign(bi);
if (inf.height > 0) {
bmp->ptr = src + ((inf.height - 1) * bmpalign);
bmp->width = inf.width;
bmp->height = inf.height;
bmp->align = bmpalign * -1;
}
else {
bmp->ptr = src;
bmp->width = inf.width;
bmp->height = inf.height * -1;
bmp->align = bmpalign;
}
bmp->pals = pals;
ZeroMemory(bmp->paltbl, sizeof(bmp->paltbl));
for (c=0; c<pals; c++) {
bmp->paltbl[c].p.b = palptr[c*4+0];
bmp->paltbl[c].p.g = palptr[c*4+1];
bmp->paltbl[c].p.r = palptr[c*4+2];
}
return(SUCCESS);
}
static UINT savegetpos(SAVEISF isf, int num) {
const BYTE *p;
p = (BYTE *)(isf + 1);
if (isf->savever <= 1) {
p += num * 4;
}
else {
p += (isf->headsize - ((isf->files - num) * 0x40));
}
return(LOADINTELDWORD(p));
}
BOOL variant_get(void *val, int num, void *value) {
if ((val == NULL) || (num < 0) || (((_VARIANT *)val)->max <= num)) {
return(FAILURE);
}
switch(((_VARIANT *)val)->type) {
case VARIANT_BIT:
{
BYTE *p = (BYTE *)&((_VARIANT *)val)[1];
*(BYTE *)value = (p[num / 8] >> (num & 7)) & 1;
}
break;
case VARIANT_SINT32:
{
BYTE *p;
p = (BYTE *)&((_VARIANT *)val)[1];
p += num * 4;
*(SINT32 *)value = LOADINTELDWORD(p);
}
break;
}
return(SUCCESS);
}
void dlgs_drawbmp(HDC hdc, UINT8 *bmp) {
BMPFILE *bf;
BMPINFO *bi;
BMPDATA inf;
HBITMAP hbmp;
UINT8 *image;
HDC hmdc;
if (bmp == NULL) {
return;
}
bf = (BMPFILE *)bmp;
bi = (BMPINFO *)(bf + 1);
if (bmpdata_getinfo(bi, &inf) != SUCCESS) {
goto dsdb_err1;
}
hbmp = CreateDIBSection(hdc, (BITMAPINFO *)bi, DIB_RGB_COLORS,
(void **)&image, NULL, 0);
if (hbmp == NULL) {
goto dsdb_err1;
}
CopyMemory(image, bmp + (LOADINTELDWORD(bf->bfOffBits)),
bmpdata_getdatasize(bi));
hmdc = CreateCompatibleDC(hdc);
SelectObject(hmdc, hbmp);
if (inf.height < 0) {
inf.height *= -1;
}
BitBlt(hdc, 0, 0, inf.width, inf.height, hmdc, 0, 0, SRCCOPY);
DeleteDC(hmdc);
DeleteObject(hbmp);
dsdb_err1:
_MFREE(bmp);
}
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);
}
UINT8 fontpc98_read(const OEMCHAR *filename, UINT8 loading) {
FILEH fh;
BMPFILE bf;
BMPINFO bi;
UINT8 *bmpdata;
BMPDATA bd;
long fptr;
if (!(loading & FONTLOAD_16)) {
goto fr98_err1;
}
// ファイルをオープン
fh = file_open_rb(filename);
if (fh == FILEH_INVALID) {
goto fr98_err1;
}
// BITMAPFILEHEADER の読み込み
if ((file_read(fh, &bf, sizeof(bf)) != sizeof(bf)) ||
(bf.bfType[0] != 'B') || (bf.bfType[1] != 'M')) {
goto fr98_err2;
}
// BITMAPINFOHEADER の読み込み
if ((file_read(fh, &bi, sizeof(bi)) != sizeof(bi)) ||
(bmpdata_getinfo(&bi, &bd) != SUCCESS) ||
(bd.width != BMPWIDTH) || (bd.height != BMPHEIGHT) || (bd.bpp != 1) ||
(LOADINTELDWORD(bi.biSizeImage) != BMPDATASIZE)) {
goto fr98_err2;
}
// BITMAPデータ頭だし
fptr = LOADINTELDWORD(bf.bfOffBits);
if (file_seek(fh, fptr, FSEEK_SET) != fptr) {
goto fr98_err2;
}
// メモリアロケート
bmpdata = (UINT8 *)_MALLOC(BMPDATASIZE, "pc98font");
if (bmpdata == NULL) {
goto fr98_err2;
}
// BITMAPデータの読みだし
if (file_read(fh, bmpdata, BMPDATASIZE) != BMPDATASIZE) {
goto fr98_err3;
}
// 8x16 フォント(〜0x7f)を読む必要がある？
if (loading & FONT_ANK16a) {
loading &= ~FONT_ANK16a;
pc98ankcpy(fontrom + 0x80000, bmpdata, 0x000, 0x080);
}
// 8x16 フォント(0x80〜)を読む必要がある？
if (loading & FONT_ANK16b) {
loading &= ~FONT_ANK16b;
pc98ankcpy(fontrom + 0x80800, bmpdata, 0x080, 0x100);
}
// 第一水準漢字を読む必要がある？
if (loading & FONT_KNJ1) {
loading &= ~FONT_KNJ1;
pc98knjcpy(fontrom, bmpdata, 0x01, 0x30);
}
// 第二水準漢字を読む必要がある？
if (loading & FONT_KNJ2) {
loading &= ~FONT_KNJ2;
pc98knjcpy(fontrom, bmpdata, 0x30, 0x56);
}
// 拡張漢字を読む必要がある？
if (loading & FONT_KNJ3) {
loading &= ~FONT_KNJ3;
pc98knjcpy(fontrom, bmpdata, 0x58, 0x60);
}
fr98_err3:
_MFREE(bmpdata);
fr98_err2:
file_close(fh);
fr98_err1:
return(loading);
}
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);
}
static BOOL readflags(SAVEHDL hdl, int num, UINT reg, UINT pos, UINT cnt) {
SAVEISF isf;
FLAGS flags;
SAVEDATA dat;
BYTE *ptr;
int remain;
int size;
BMPINFO *bi;
UINT bmpsize;
UINT type;
isf = (SAVEISF)(hdl + 1);
if ((num < 0) || (num >= isf->gamesaves)) {
goto sfrg_err1;
}
flags = &gamecore.flags;
type = gamecore.sys.type;
dat = saveread(isf, num);
if (dat == NULL) {
goto sfrg_err1;
}
ptr = dat->ptr + sizeof(_SYSTIME);
remain = dat->size - sizeof(_SYSTIME);
if (remain < 0) {
goto sfrg_err2;
}
if (type & GAME_SAVEGRPH) {
remain -= sizeof(BMPINFO);
if (remain < 0) {
goto sfrg_err2;
}
bi = (BMPINFO *)ptr;
ptr += sizeof(BMPINFO);
bmpsize = bmpdata_getdatasizeex(bi, FALSE);
remain -= bmpsize;
if (remain < 0) {
goto sfrg_err2;
}
ptr += bmpsize;
}
size = 0;
if (type & GAME_SAVECOM) {
size += isf->commsize;
}
size += flags->flagsize;
if (remain < (size + (int)(flags->maxval * 4))) {
goto sfrg_err2;
}
ptr += size;
remain -= size;
while(cnt) {
if ((reg < flags->maxval) && (pos < flags->maxval)) {
flags->val[reg] = LOADINTELDWORD(ptr + (pos * 4));
}
reg++;
pos++;
cnt--;
}
_MFREE(dat);
return(SUCCESS);
sfrg_err2:
_MFREE(dat);
sfrg_err1:
return(FAILURE);
}
static BOOL readgame(SAVEHDL hdl, int num) {
SAVEISF isf;
FLAGS flags;
SAVEDATA dat;
BYTE *ptr;
int remain;
int size;
UINT i;
BMPINFO *bi;
UINT bmpsize;
UINT type;
isf = (SAVEISF)(hdl + 1);
if ((num < 0) || (num >= isf->gamesaves)) {
goto sfrg_err1;
}
flags = &gamecore.flags;
type = gamecore.sys.type;
dat = saveread(isf, num);
if (dat == NULL) {
goto sfrg_err1;
}
ptr = dat->ptr + sizeof(_SYSTIME);
remain = dat->size - sizeof(_SYSTIME);
if (remain < 0) {
goto sfrg_err2;
}
if (type & GAME_SAVEGRPH) {
remain -= sizeof(BMPINFO);
if (remain < 0) {
goto sfrg_err2;
}
bi = (BMPINFO *)ptr;
ptr += sizeof(BMPINFO);
bmpsize = bmpdata_getdatasizeex(bi, FALSE);
remain -= bmpsize;
if (remain < 0) {
goto sfrg_err2;
}
ptr += bmpsize;
}
size = 0;
if (type & GAME_SAVECOM) {
size += isf->commsize;
}
size += flags->flagsize;
size += flags->maxval * 4;
if (remain < size) {
goto sfrg_err2;
}
if (type & GAME_SAVECOM) {
if (!(type & GAME_SAVEAUTOCOM)) {
CopyMemory(gamecore.comment, ptr, isf->commsize);
}
ptr += isf->commsize;
remain -= isf->commsize;
}
size = flags->flagsize;
if (size) {
CopyMemory(flags->flag, ptr, size);
ptr += size;
remain -= size;
}
for (i=0; i<flags->maxval; i++) {
flags->val[i] = LOADINTELDWORD(ptr);
ptr += 4;
remain -= 4;
}
_MFREE(dat);
scr_restart("LOAD");
return(SUCCESS);
sfrg_err2:
_MFREE(dat);
sfrg_err1:
return(FAILURE);
}
static BOOL readinf(SAVEHDL hdl, int num, SAVEINF inf,
int width, int height) {
SAVEISF isf;
SAVEDATA dat;
int remain;
BYTE *ptr;
BMPINFO *bi;
UINT bmpsize;
if (inf == NULL) {
goto sfrt_err1;
}
ZeroMemory(inf, sizeof(_SAVEINF));
isf = (SAVEISF)(hdl + 1);
if ((num < 0) || (num >= isf->gamesaves)) {
goto sfrt_err1;
}
dat = saveread(isf, num);
if (dat == NULL) {
goto sfrt_err1;
}
ptr = dat->ptr;
remain = dat->size;
remain -= sizeof(_SYSTIME);
if (remain < 0) {
goto sfrt_err2;
}
savefile_cnvdate(&inf->date, ptr);
ptr += sizeof(_SYSTIME);
if (gamecore.sys.type & GAME_SAVEGRPH) {
remain -= sizeof(BMPINFO);
if (remain < 0) {
goto sfrt_err2;
}
bi = (BMPINFO *)ptr;
if (LOADINTELDWORD(bi->biSize) != sizeof(BMPINFO)) {
goto sfrt_err2;
}
ptr += sizeof(BMPINFO);
bmpsize = bmpdata_getdatasizeex(bi, FALSE);
remain -= bmpsize;
if (remain < 0) {
goto sfrt_err2;
}
if (width < 0) {
width = LOADINTELDWORD(bi->biWidth);
#ifdef SIZE_QVGA
width = vramdraw_half(width);
#endif
}
if (height < 0) {
height = (SINT32)LOADINTELDWORD(bi->biHeight);
if (height < 0) {
height *= -1;
}
#ifdef SIZE_QVGA
height = vramdraw_half(height);
#endif
}
inf->preview = bmpdata_vram24cnvex(width, height, bi, ptr, FALSE);
ptr += bmpsize;
}
inf->comment[0] = '\0';
if (gamecore.sys.type & GAME_SAVECOM) {
remain -= isf->commsize;
if (remain < 0) {
goto sfrt_err2;
}
CopyMemory(inf->comment, ptr, isf->commsize);
inf->comment[isf->commsize] = '\0';
ptr += isf->commsize;
}
_MFREE(dat);
return(SUCCESS);
sfrt_err2:
vram_destroy((VRAMHDL)inf->preview);
inf->preview = NULL;
_MFREE(dat);
sfrt_err1:
return(FAILURE);
}
static FILEH saveopen(SAVEISF isf, BOOL create) {
FILEH fh;
char path[MAX_PATH];
BOOL r;
milstr_ncpy(path, gamecore.suf.scriptpath, sizeof(path));
if (!(gamecore.sys.type & GAME_SAVEALIAS)) {
switch(gamecore.sys.version) {
case EXEVER_MYU:
case EXEVER_AMEIRO:
case EXEVER_NURSE:
case EXEVER_VECHO:
milstr_ncat(path, "GAME.SAV", sizeof(path));
break;
case EXEVER_TSUKU:
milstr_ncat(path, "TSUKU.SAV", sizeof(path));
break;
default:
milstr_ncat(path, gamecore.suf.key, sizeof(path));
milstr_ncat(path, ".SAV", sizeof(path));
break;
}
}
else {
milstr_ncat(path, "xkazoku.sav", sizeof(path));
}
TRACEOUT(("savefile: %s", path));
if (!create) {
fh = file_open_rb(path);
}
else {
fh = file_open(path);
}
if (fh != FILEH_INVALID) {
if (isf->savever == 2) {
BYTE work[8];
if (file_read(fh, work, 8) == 8) {
isf->headsize = LOADINTELDWORD(work+0);
isf->files = LOADINTELDWORD(work+4);
}
file_seek(fh, 0, FSEEK_SET);
}
}
else if (create) {
fh = file_create(path);
if (fh != FILEH_INVALID) {
if (isf->savever == 0) {
r = savezerofill(fh, savegetinitsize(isf));
}
else if (isf->savever == 1) {
r = savezerofill(fh, isf->headsize);
}
else {
r = savever2header(fh, isf);
}
if (r != SUCCESS) {
file_close(fh);
fh = FILEH_INVALID;
file_delete(path);
}
}
}
return(fh);
}
