struct cdtoc
{
struct zfile *handle;
- int offset;
+ uae_s64 offset;
uae_u8 *data;
struct zfile *subhandle;
int suboffset;
uae_u8 *subdata;
- int filesize;
+ uae_s64 filesize;
TCHAR *fname;
int address;
uae_u8 adr, ctrl;
totalsize += t->size;
offset = t->size;
}
- zfile_fseek (t->subhandle, sector * totalsize + t->suboffset + offset, SEEK_SET);
+ zfile_fseek (t->subhandle, (uae_u64)sector * totalsize + t->suboffset + offset, SEEK_SET);
if (zfile_fread (dst, SUB_CHANNEL_SIZE, 1, t->subhandle) > 0)
ret = t->subcode;
} else {
write_log (_T("IMAGE CDDA: illegal sector number %d\n"), cdu->cdda_start);
setstate (cdu, AUDIO_STATUS_PLAY_ERROR);
} else {
- write_log (_T("IMAGE CDDA: playing from %d to %d, track %d ('%s', offset %d, secoffset %d)\n"),
+ write_log (_T("IMAGE CDDA: playing from %d to %d, track %d ('%s', offset %lld, secoffset %d)\n"),
cdu->cdda_start, cdu->cdda_end, t->track, t->fname, t->offset, sector);
// do this even if audio is not compressed, t->handle also could be
// compressed and we want to unpack it in background too
memcpy (dst, t->data + sector * totalsize + t->offset, t->size);
} else if (t->enctype == AUDENC_PCM) {
if (sector * totalsize + t->offset + totalsize < t->filesize) {
- zfile_fseek (t->handle, sector * totalsize + t->offset, SEEK_SET);
+ zfile_fseek (t->handle, (uae_u64)sector * totalsize + t->offset, SEEK_SET);
zfile_fread (dst, t->size, 1, t->handle);
}
}
// 2048 -> 2352
while (size-- > 0) {
memset (data, 0, 16);
- zfile_fseek (t->handle, t->offset + sector * t->size, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size, SEEK_SET);
zfile_fread (data + 16, t->size, 1, t->handle);
encode_l2 (data, sector + 150);
sector++;
// 2352 -> 2048
while (size-- > 0) {
uae_u8 b = 0;
- zfile_fseek (t->handle, t->offset + sector * t->size + 15, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 15, SEEK_SET);
zfile_fread (&b, 1, 1, t->handle);
if (b == 2) // MODE2?
- zfile_fseek (t->handle, t->offset + sector * t->size + 24, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 24, SEEK_SET);
zfile_fread (data, sectorsize, 1, t->handle);
sector++;
data += sectorsize;
// 2352 -> 2336
while (size-- > 0) {
uae_u8 b = 0;
- zfile_fseek (t->handle, t->offset + sector * t->size + 15, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 15, SEEK_SET);
zfile_fread (&b, 1, 1, t->handle);
if (b != 2 && b != 0) // MODE0 or MODE2 only allowed
return 0;
}
} else if (sectorsize == t->size) {
// no change
- zfile_fseek (t->handle, t->offset + sector * t->size, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size, SEEK_SET);
zfile_fread (data, sectorsize, size, t->handle);
sector += size;
}
goto end;
}
for (int i = 0; i < size; i++) {
- zfile_fseek (t->handle, t->offset + sector * t->size, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size, SEEK_SET);
zfile_fread (data, t->size, 1, t->handle);
uae_u8 *p = data + t->size;
if (subs) {
return 0;
cdda_stop (cdu);
if (t->size == 2048) {
- zfile_fseek (t->handle, t->offset + sector * t->size, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size, SEEK_SET);
zfile_fread (data, size, 2048, t->handle);
sector += size;
} else {
while (size-- > 0) {
if (t->size == 2352) {
uae_u8 b = 0;
- zfile_fseek (t->handle, t->offset + sector * t->size + 15, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 15, SEEK_SET);
zfile_fread (&b, 1, 1, t->handle);
if (b == 2) // MODE2?
- zfile_fseek (t->handle, t->offset + sector * t->size + 24, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 24, SEEK_SET);
} else {
- zfile_fseek (t->handle, t->offset + sector * t->size + 16, SEEK_SET);
+ zfile_fseek (t->handle, t->offset + (uae_u64)sector * t->size + 16, SEEK_SET);
}
zfile_fread (data, 1, 2048, t->handle);
data += 2048;
MDS_Header *head;
struct cdtoc *t;
uae_u8 *mds = NULL;
+ uae_u64 size;
write_log (_T("MDS TOC: '%s'\n"), img);
- int size = zfile_size (zmds);
+ size = zfile_size (zmds);
mds = xmalloc (uae_u8, size);
if (!mds)
goto end;
static int parsecue (struct cdunit *cdu, struct zfile *zcue, const TCHAR *img)
{
- int tracknum, index0, pregap;
- int offset, secoffset, newfile;
+ int tracknum, pregap;
+ int newfile, secoffset;
+ uae_s64 offset, index0;
TCHAR *fname, *fnametype;
audenc fnametypeid;
int ctrl;
if (tracknum > 1 && newfile) {
t--;
- secoffset += t->filesize / t->size;
+ secoffset += (int)(t->filesize / t->size);
t++;
}
}
struct cdtoc *t = &cdu->toc[cdu->tracks - 1];
- int size = t->filesize;
+ uae_s64 size = t->filesize;
if (!secoffset)
size -= offset * t->size;
if (size < 0)
size = 0;
- cdu->toc[cdu->tracks].address = t->address + size / t->size;
+ cdu->toc[cdu->tracks].address = t->address + (int)(size / t->size);
xfree (fname);
t->size = (siz % 2048) == 0 ? 2048 : 2352;
t->filesize = siz;
write_log (_T("CD: plain CD image mounted!\n"));
- cdu->toc[1].address = t->address + t->filesize / t->size;
+ cdu->toc[1].address = t->address + (int)(t->filesize / t->size);
zcue = NULL;
}
}
write_log (_T("%7d %02d:%02d:%02d"),
t->address, (msf >> 16) & 0xff, (msf >> 8) & 0xff, (msf >> 0) & 0xff);
if (i < cdu->tracks)
- write_log (_T(" %s %x %10d %10d %s"), (t->ctrl & 4) ? _T("DATA ") : (t->subcode ? _T("CDA+SUB") : _T("CDA ")),
+ write_log (_T(" %s %x %10lld %10lld %s"), (t->ctrl & 4) ? _T("DATA ") : (t->subcode ? _T("CDA+SUB") : _T("CDA ")),
t->ctrl, t->offset, t->filesize, t->handle == NULL ? _T("[FILE ERROR]") : _T(""));
write_log (_T("\n"));
if (i < cdu->tracks)
di->mediapath[0] = 0;
di->cylinders = 1;
di->trackspercylinder = 1;
- di->sectorspertrack = cdu->cdsize / di->bytespersector;
+ di->sectorspertrack = (int)(cdu->cdsize / di->bytespersector);
if (ismedia (unitnum, 1)) {
di->media_inserted = 1;
_tcscpy (di->mediapath, currprefs.cdslots[unitnum].name);
#ifdef BSDSOCKET
+int log_bsd;
struct socketbase *socketbases;
static uae_u32 SockLibBase;
static struct chipset_refresh *stored_chipset_refresh;
int doublescan;
bool programmedmode;
-frame_time_t syncbase;
+int syncbase;
static int fmode;
uae_u16 beamcon0, new_beamcon0;
uae_u16 vtotal = MAXVPOS_PAL, htotal = MAXHPOS_PAL;
write_log (_T("%s mode%s%s V=%.4fHz H=%0.4fHz (%dx%d+%d) IDX=%d (%s)\n"),
isntsc ? _T("NTSC") : _T("PAL"),
- islace ? _T(" laced") : _T(""),
+ islace ? _T(" lace") : _T(""),
doublescan > 0 ? _T(" dblscan") : _T(""),
- vblank_hz, vblank_hz * maxvpos_nom,
+ vblank_hz,
+ (double)(currprefs.ntscmode ? CHIPSET_CLOCK_NTSC : CHIPSET_CLOCK_PAL) / (maxhpos + (islinetoggle () ? 0.5 : 0)),
maxhpos, maxvpos, lof_store ? 1 : 0,
cr ? cr->index : -1,
cr != NULL && cr->label != NULL ? cr->label : _T("<?>")
equ_vblank_endline = EQU_ENDLINE_NTSC;
equ_vblank_toggle = false;
}
+ // long/short field refresh rate adjustment
+ vblank_hz = vblank_hz * (maxvpos * 2 + 1) / ((maxvpos + lof_current) * 2);
+
maxvpos_nom = maxvpos;
if (vpos_count > 0) {
// we come here if vpos_count != maxvpos and beamcon0 didn't change
if (vblank_hz != ovblank)
updatedisplayarea ();
inputdevice_tablet_strobe ();
+
+ if (fullinit)
+ vpos_count_diff = maxvpos_nom;
}
void init_hz (void)
static void do_savestate(void);
-static int rpt_vsync (void)
+static int rpt_vsync (int adjust)
{
frame_time_t curr_time = read_processor_time ();
- int v = curr_time - vsyncwaittime;
- if (v > (int)syncbase || v < -((int)syncbase)) {
+ int v = curr_time - vsyncwaittime + adjust;
+ if (v > syncbase || v < -syncbase) {
vsyncmintime = vsyncmaxtime = vsyncwaittime = curr_time;
v = 0;
}
}
}
-extern int log_vsync;
+
+// moving average algorithm
+#define MAVG_SIZE 128
+struct mavg_data
+{
+ int values[MAVG_SIZE];
+ int size;
+ int offset;
+ int mavg;
+};
+
+static int mavg (struct mavg_data *md, int newval)
+{
+ if (md->size < MAVG_SIZE) {
+ md->values[md->size++] = newval;
+ md->mavg += newval;
+ } else {
+ md->mavg -= md->values[md->offset];
+ md->values[md->offset] = newval;
+ md->mavg += newval;
+ md->offset++;
+ if (md->offset >= MAVG_SIZE)
+ md->offset -= MAVG_SIZE;
+ }
+ return md->mavg / md->size;
+}
+
+extern int log_vsync, debug_vsync_min_delay, debug_vsync_forced_delay;
static bool framewait (void)
{
frame_time_t curr_time;
frame_time_t start;
int vs = isvsync_chipset ();
- int frameskipt;
- bool ok = true;
-
- frameskipt = frameskiptime;
- frameskiptime = 0;
-
- /* note to anyone reading this: below ugly uae_s64 averaging stuff will be replaced with
- * something more optimal after vsync timing works correctly enough
- */
+ int status = 0;
is_syncline = 0;
- static uae_s64 frameskipt64;
- static int frameskipt64cnt;
+ static struct mavg_data ma_frameskipt;
+ int frameskipt_avg = mavg (&ma_frameskipt, frameskiptime);
- frameskipt64cnt++;
- if (frameskipt > frameskipt64 / frameskipt64cnt)
- frameskipt64 = (uae_s64)frameskipt * frameskipt64cnt;
- else
- frameskipt64 += frameskipt;
+ frameskiptime = 0;
if (vs > 0) {
+ static struct mavg_data ma_legacy;
static frame_time_t vsync_time;
- static uae_s64 legacy64;
- static int legacy64cnt;
int t;
curr_time = read_processor_time ();
if (!frame_shown)
show_screen ();
- legacy64cnt++;
- if (t > legacy64 / legacy64cnt)
- legacy64 = (uae_s64)t * legacy64cnt;
- else
- legacy64 += t;
+ int legacy_avg = mavg (&ma_legacy, t);
+ if (t > legacy_avg)
+ legacy_avg = t;
+ t = legacy_avg;
- t = legacy64 / legacy64cnt;
+ if (debug_vsync_min_delay && t < debug_vsync_min_delay * vsynctimebase / 100)
+ t = debug_vsync_min_delay * vsynctimebase / 100;
+ if (debug_vsync_forced_delay > 0)
+ t = debug_vsync_forced_delay * vsynctimebase / 100;
vsync_time = read_processor_time ();
if (t > vsynctimebase * 2 / 3)
t = vsynctimebase * 2 / 3;
if (currprefs.m68k_speed < 0) {
- vsynctimeperline = (vsynctimebase - t * 2) / (maxvpos_nom + 1);
+ vsynctimeperline = (vsynctimebase - t) / (maxvpos_nom + 1);
} else {
vsynctimeperline = (vsynctimebase - t) / 3;
}
vsynctimeperline = 1;
if (0 || (log_vsync & 2)) {
- write_log (L"%06d %06d/%06d\n", t, vsynctimeperline, vsynctimebase);
+ write_log (L"%06d %06d/%06d %03d%%\n", t, vsynctimeperline, vsynctimebase, t * 100 / vsynctimebase);
}
frame_shown = true;
- return ok;
+ return status != 0;
} else if (vs < 0) {
extern int extraframewait;
if (!vblank_hz_state)
- return ok;
+ return status != 0;
if (vs == -2 || vs == -3) {
// fastest possible
- static int skipcnt;
int max, adjust, flipdelay, val;
frame_time_t now;
- static uae_s64 skipcnt64, adjust64;
- static int llvsynccnt;
+ static struct mavg_data ma_skip, ma_adjust;
+
+ val = 0;
if (!frame_rendered && !picasso_on) {
frame_time_t start, end;
start = read_processor_time ();
frame_rendered = render_screen (currprefs.gfx_apmode[0].gfx_vflip == 0);
end = read_processor_time ();
- frameskipt += end - start;
+ val += end - start;
}
curr_time = vsync_busywait_end (&flipdelay); // vsync time
- ok = vsync_busywait_do (NULL, (bplcon0 & 4) != 0 && !lof_changed && !lof_changing, lof_store != 0);
+ status = vsync_busywait_do (NULL, (bplcon0 & 4) != 0 && !lof_changed && !lof_changing, lof_store != 0);
vsync_busywait_start ();
- llvsynccnt++;
-
- if (flipdelay > skipcnt64 / llvsynccnt)
- skipcnt64 = (uae_s64)flipdelay * llvsynccnt;
- else
- skipcnt64 += flipdelay;
-
now = read_processor_time (); // current time
adjust = (int)now - (int)curr_time;
//write_log (_T("%d "), adjust);
- if (adjust < 0)
+ if (adjust < 0 || adjust >= vsynctimebase)
adjust = 0;
if (adjust > vsynctimebase * 2 / 3)
adjust = vsynctimebase * 2 / 3;
- adjust64 += adjust;
- //write_log (_T("%d "), adjust);
+ int adjust_avg = mavg (&ma_adjust, adjust);
- val = adjust64 / llvsynccnt;
+ val += adjust_avg;
+ int flipdelay_avg = mavg (&ma_skip, flipdelay);
+ if (flipdelay > flipdelay_avg)
+ flipdelay_avg = flipdelay;
if (currprefs.gfx_apmode[0].gfx_vflip == 0) {
- val += skipcnt64 / llvsynccnt;
+ val += flipdelay_avg;
//write_log (_T("%d "), skipcnt);
}
- val += frameskipt64 / frameskipt64cnt;
+ val += frameskipt_avg;
+
+ if (currprefs.gfx_apmode[0].gfx_vflip == 0) {
+ if (debug_vsync_min_delay && val < debug_vsync_min_delay * vsynctimebase / 100)
+ val = debug_vsync_min_delay * vsynctimebase / 100;
+ if (debug_vsync_forced_delay > 0)
+ val = debug_vsync_forced_delay * vsynctimebase / 100;
+ }
+
//write_log (_T("%d "), adjust);
if (val > vsynctimebase * 2 / 3)
vsyncwaittime = curr_time + (vsynctimebase - 0);
vsynctimeperline = max / (maxvpos_nom + 1);
- if (vsynctimeperline < 1)
+ if (status <= 0 || vsynctimeperline < 1)
vsynctimeperline = 1;
vsyncmaxtime = now + max;
if (0 || (log_vsync & 2)) {
- write_log (L"%05d:%05d:%05d=%05d:%05d/%05d\n", (int)(adjust64 / llvsynccnt), (int)(frameskipt64 / frameskipt64cnt), (int)(skipcnt64 / llvsynccnt), val, vsynctimeperline, vsynctimebase);
+ write_log (L"%05d:%05d:%05d=%05d:%05d/%05d %03d%%\n", adjust_avg, frameskipt_avg, flipdelay_avg,
+ val, vsynctimeperline, vsynctimebase, val * 100 / vsynctimebase);
}
+ frame_shown = true;
+
} else {
- static int skipcnt;
- int max, adjust, flipdelay;
- static uae_s64 skipcnt64;
- static int llvsynccnt;
+ int max, adjust, flipdelay, flipdelay_avg;
+ static struct mavg_data ma_skip;
frame_time_t now;
flipdelay = 0;
if (!frame_rendered && !picasso_on)
frame_rendered = render_screen (false);
- ok = vsync_busywait_do (&freetime, (bplcon0 & 4) != 0 && !lof_changed && !lof_changing, lof_store != 0);
curr_time = vsync_busywait_end (&flipdelay);
+ status = vsync_busywait_do (&freetime, (bplcon0 & 4) != 0 && !lof_changed && !lof_changing, lof_store != 0);
+ vsync_busywait_start ();
+
if (extraframewait && !currprefs.turbo_emulation)
sleep_millis_main (extraframewait);
+
now = read_processor_time ();
adjust = (int)now - (int)curr_time;
+ int adjustx = adjust;
if (adjust < 0)
adjust = 0;
if (adjust > vsynctimebase)
adjust = 0;
if (adjust > vsynctimebase / 2)
adjust = vsynctimebase / 2;
- max = vsynctimebase - (adjust * 3 / 2);
vsyncmintime = now;
vsyncwaittime = curr_time + vsynctimebase;
if (currprefs.gfx_apmode[0].gfx_vflip == 0) {
- llvsynccnt++;
- if (flipdelay > skipcnt64 / llvsynccnt)
- skipcnt64 = (uae_s64)flipdelay * llvsynccnt;
- else
- skipcnt64 += flipdelay;
+ flipdelay_avg = mavg (&ma_skip, flipdelay);
+ if (flipdelay > flipdelay_avg)
+ flipdelay_avg = flipdelay;
} else {
- skipcnt64 = 0;
- llvsynccnt = 1;
+ flipdelay_avg = 0;
+ }
+
+ max = vsynctimebase - adjust - flipdelay_avg;
+
+ if (currprefs.gfx_apmode[0].gfx_vflip == 0) {
+ int val = vsynctimebase - max;
+ if (debug_vsync_min_delay && val < debug_vsync_min_delay * vsynctimebase / 100)
+ val = debug_vsync_min_delay * vsynctimebase / 100;
+ if (debug_vsync_forced_delay > 0)
+ val = debug_vsync_forced_delay * vsynctimebase / 100;
+ max = vsynctimebase - val;
}
- vsynctimeperline = (max - (skipcnt64 / llvsynccnt) * 2) / 3;
- if (vsynctimeperline < 1)
+ vsynctimeperline = max / 3;
+ if (status <= 0 || vsynctimeperline < 1)
vsynctimeperline = 1;
vsyncmaxtime = now + max;
if (0 || (log_vsync & 2)) {
- write_log (L"%06d:%06d:%06d:%06d/%06d\n", (int)(frameskipt64 / frameskipt64cnt), (int)(skipcnt64 / llvsynccnt), adjust, vsynctimeperline, vsynctimebase);
+ write_log (L"%06d:%06d:%06d:%06d %06d/%06d %03d%%\n", frameskipt_avg, flipdelay_avg, adjust, adjustx,
+ vsynctimeperline, vsynctimebase, (vsynctimebase - max) * 100 / vsynctimebase);
}
frame_shown = true;
}
- return ok;
+ return status != 0;
}
+ int clockadjust = 0;
+#if 0
+ static uae_u32 prevtick;
+ static int frametickcnt;
+
+ uae_u32 tick = read_system_time (); // milliseconds
+ uae_s32 tickdiff = tick - prevtick;
+ uae_s32 framems = (frametickcnt * 1000) / (int)(vblank_hz + 0.5);
+ if (abs (framems - tickdiff) >= 2000) {
+ framems = 0;
+ tickdiff = 0;
+ prevtick = tick;
+ frametickcnt = 0;
+ write_log (L"!\n");
+ } else {
+ frametickcnt++;
+ }
+ int diff = (framems - tickdiff) / 1;
+ if (diff < -5000)
+ diff = -5000;
+ else if (diff > 5000)
+ diff = 5000;
+ clockadjust = -vsynctimebase * diff / 1000;
+ clockadjust *= 100;
+ write_log (L"%d:%d:%d\n", framems - tickdiff, diff, clockadjust);
+#endif
if (currprefs.m68k_speed < 0) {
if (!frame_rendered && !picasso_on)
int max;
int adjust = 0;
if ((int)curr_time - (int)vsyncwaittime > 0 && (int)curr_time - (int)vsyncwaittime < vsynctimebase / 2)
- adjust = curr_time - vsyncwaittime;
+ adjust += curr_time - vsyncwaittime;
+ adjust += clockadjust;
max = vsynctimebase * (1000 + currprefs.m68k_speed_throttle) / 1000 - adjust;
vsyncwaittime = curr_time + vsynctimebase - adjust;
vsyncmintime = curr_time;
-
-#if 0
- max -= frameskipt;
-#endif
+
if (max < 0) {
max = 0;
vsynctimeperline = 1;
vsynctimeperline = max / (maxvpos_nom + 1);
}
vsyncmaxtime = curr_time + max;
+
+ if (0)
+ write_log (_T("%06d:%06d/%06d\n"), adjust, vsynctimeperline, vsynctimebase);
} else {
t = read_processor_time () - start;
}
while (!currprefs.turbo_emulation) {
- double v = rpt_vsync () / (syncbase / 1000.0);
+ double v = rpt_vsync (clockadjust) / (syncbase / 1000.0);
if (v >= -4)
break;
rtg_vsynccheck ();
sleep_millis_main (2);
}
curr_time = start = read_processor_time ();
- while (rpt_vsync () < 0)
+ while (rpt_vsync (clockadjust) < 0)
rtg_vsynccheck ();
idletime += read_processor_time() - start;
curr_time = read_processor_time ();
show_screen ();
t += read_processor_time () - curr_time;
}
- t += frameskipt;
- vsynctimeperline = (vsynctimebase - (t + frameskipt)) / 3;
+ t += frameskipt_avg;
+ vsynctimeperline = (vsynctimebase - t) / 3;
if (vsynctimeperline < 0)
vsynctimeperline = 0;
else if (vsynctimeperline > vsynctimebase / 3)
frame_shown = true;
}
- return ok;
+ return status != 0;
}
}
#endif
- if ((beamcon0 & (0x20 | 0x80)) != (new_beamcon0 & (0x20 | 0x80)) || abs (vpos_count - vpos_count_diff) > 1 || lof_changed) {
+ if ((beamcon0 & (0x20 | 0x80)) != (new_beamcon0 & (0x20 | 0x80)) || (vpos_count > 0 && abs (vpos_count - vpos_count_diff) > 1) || lof_changed) {
init_hz ();
} else if (interlace_changed || changed_chipset_refresh ()) {
compute_framesync ();
is_syncline = 0;
} else {
vsyncmintime = vsyncmaxtime; /* emulate if still time left */
- is_syncline_end = read_processor_time () + vsynctimebase;
+ is_syncline_end = read_processor_time () + vsynctimebase; /* far enough in future, we never wait that long */
is_syncline = 1;
}
} else {
vsyncmintime += vsynctimeperline;
linecounter++;
is_syncline = 0;
- if (!vblank_found_chipset && !currprefs.turbo_emulation) {
+ if (!vsync_isdone () && !currprefs.turbo_emulation) {
if ((int)vsyncmaxtime - (int)vsyncmintime > 0) {
if ((int)vsyncwaittime - (int)vsyncmintime > 0) {
frame_time_t rpt = read_processor_time ();
}
}
} else {
- if (!currprefs.turbo_emulation && (vpos + 1 < maxvpos + lof_store && (vpos == maxvpos_nom * 1 / 3 || vpos == maxvpos_nom * 2 / 3))) {
+ if (!vsync_isdone () && !currprefs.turbo_emulation && (vpos + 1 < maxvpos + lof_store && (vpos == maxvpos_nom * 1 / 3 || vpos == maxvpos_nom * 2 / 3))) {
frame_time_t rpt = read_processor_time ();
vsyncmintime += vsynctimeperline;
// sleep if more than 2ms "free" time
- while (!vblank_found_chipset && (int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
+ while (!vsync_isdone () && (int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
sleep_millis_main (1);
rpt = read_processor_time ();
//write_log (L"*");
if (diw_change > 0)
diw_change--;
- if (is_last_line () && isvsync_chipset () == -2 && !vsync_rendered && currprefs.gfx_apmode[0].gfx_vflip == 0) {
+ /* fastest possible + last line and no vflip wait: render the frame as early as possible */
+ if (is_last_line () && isvsync_chipset () <= -2 && !vsync_rendered && currprefs.gfx_apmode[0].gfx_vflip == 0) {
frame_time_t start, end;
start = read_processor_time ();
- /* fastest possible + last line and no vflip wait: render the frame as early as possible */
vsync_rendered = true;
vsync_handle_redraw (lof_store, lof_changed, bplcon0, bplcon3);
if (vblank_hz_state) {
frame_rendered = render_screen (true);
}
- frame_shown = true;
end = read_processor_time ();
frameskiptime += end - start;
}
drv->dskchange_time = 0;
restore_u32 ();
s = restore_path (SAVESTATE_PATH_FLOPPY);
+ if (s && s[0])
+ write_log (L"-> '%s'\n", s);
_tcscpy (old, currprefs.floppyslots[num].df);
_tcsncpy (changed_prefs.floppyslots[num].df, s, 255);
xfree (s);
long cycles_to_hsync_event;
unsigned long start_cycles;
-frame_time_t vsynctimebase, vsyncmintime, vsyncmaxtime, vsyncwaittime;
+frame_time_t vsyncmintime, vsyncmaxtime, vsyncwaittime;
+int vsynctimebase;
void events_schedule (void)
{
int rpt = read_processor_time ();
int v = rpt - vsyncmintime;
int v2 = rpt - is_syncline_end;
- if (v > (int)vsynctimebase || v < -((int)vsynctimebase)) {
+ if (v > vsynctimebase || v < -vsynctimebase) {
v = 0;
}
if (v < 0 && v2 < 0) {
double getvsyncrate (double hz, int *mult)
{
+ struct apmode *ap = picasso_on ? &currprefs.gfx_apmode[1] : &currprefs.gfx_apmode[0];
+
if (hz < 0)
return 0;
if (hz > 85) {
return hz / 2;
}
if (hz < 35 && hz > 0) {
- *mult = 1;
+ if (ap->gfx_interlaced)
+ *mult = 0;
+ else
+ *mult = 1;
return hz * 2;
}
*mult = 0;
*
*/
-//#define TRACING_ENABLED
+#define BSD_TRACING_ENABLED 0
-#ifdef TRACING_ENABLED
-#define BSDTRACE(x) do { write_log x; } while(0)
-#else
-#define BSDTRACE(x)
-#endif
+extern int log_bsd;
+
+#define ISBSDTRACE (log_bsd || BSD_TRACING_ENABLED)
+#define BSDTRACE(x) do { if (ISBSDTRACE) { write_log x; } } while(0)
extern int init_socket_layer (void);
extern void deinit_socket_layer (void);
#define CSMASK_AGA 4
#define CSMASK_MASK (CSMASK_ECS_AGNUS | CSMASK_ECS_DENISE | CSMASK_AGA)
+#define CHIPSET_CLOCK_PAL 3546895
+#define CHIPSET_CLOCK_NTSC 3579545
+
uae_u32 get_copper_address (int copno);
extern int custom_init (void);
extern double vblank_hz, fake_vblank_hz;
extern int vblank_skip, doublescan;
extern bool programmedmode;
-extern frame_time_t syncbase;
#define DMA_AUD0 0x0001
#define DMA_AUD1 0x0002
#include "machdep/rpt.h"
-extern frame_time_t vsynctimebase, vsyncmintime, vsyncmaxtime, vsyncwaittime;
+extern frame_time_t vsyncmintime, vsyncmaxtime, vsyncwaittime;
+extern int vsynctimebase, syncbase;
extern void reset_frame_rate_hack (void);
-extern frame_time_t syncbase;
extern unsigned long int vsync_cycles;
extern unsigned long start_cycles;
* function has to be setup with deftrap2() and
* TRAPFLAG_EXTRA_STACK and stack magic is required.
*/
-uaecptr uae_AllocMem (TrapContext *context, uae_u32 size, uae_u32 flags);
-void uae_FreeMem (TrapContext *context, uaecptr memory, uae_u32 size);
+uaecptr uae_AllocMem (TrapContext *context, uae_u32 size, uae_u32 flags, uaecptr sysbase);
+void uae_FreeMem (TrapContext *context, uaecptr memory, uae_u32 size, uaecptr sysbase);
/*
extern void desktop_coords (int *dw, int *dh, int *x, int *y, int *w, int *h);
extern bool vsync_switchmode (int);
extern frame_time_t vsync_busywait_end (int*);
-extern bool vsync_busywait_do (int*, bool, bool);
+extern int vsync_busywait_do (int*, bool, bool);
extern void vsync_busywait_start (void);
extern double vblank_calibrate (double, bool);
+extern bool vsync_isdone (void);
extern void doflashscreen (void);
extern int flashscreen;
extern void updatedisplayarea (void);
x_put_long (list + 8, list);
}
-uaecptr uae_AllocMem (TrapContext *context, uae_u32 size, uae_u32 flags)
+uaecptr uae_AllocMem (TrapContext *context, uae_u32 size, uae_u32 flags, uaecptr sysbase)
{
m68k_dreg (regs, 0) = size;
m68k_dreg (regs, 1) = flags;
- return CallLib (context, x_get_long (4), -198); /* AllocMem */
+ return CallLib (context, sysbase, -198); /* AllocMem */
}
-void uae_FreeMem (TrapContext *context, uaecptr memory, uae_u32 size)
+void uae_FreeMem (TrapContext *context, uaecptr memory, uae_u32 size, uaecptr sysbase)
{
m68k_dreg (regs, 0) = size;
m68k_areg (regs, 1) = memory;
- CallLib (context, x_get_long (4), -0xD2); /* FreeMem */
+ CallLib (context, sysbase, -0xD2); /* FreeMem */
}
currprefs.cpu_clock_multiplier = changed_prefs.cpu_clock_multiplier;
currprefs.cpu_frequency = changed_prefs.cpu_frequency;
- baseclock = currprefs.ntscmode ? 28636360 : 28375160;
+ baseclock = (currprefs.ntscmode ? CHIPSET_CLOCK_NTSC : CHIPSET_CLOCK_PAL) * 8;
cpucycleunit = CYCLE_UNIT / 2;
if (currprefs.cpu_clock_multiplier) {
if (currprefs.cpu_clock_multiplier >= 256) {
reseterrormode (ciw);
if (!status) {
DWORD err = GetLastError ();
- write_log (_T("IOCTL_RAW_SCSI unit %d, CMD=%d, ERR=%d "), unitnum, cmd[0], err);
+ write_log (_T("IOCTL_RAW_SCSI unit %d, CMD=%d, ERR=%d\n"), unitnum, cmd[0], err);
return 0;
}
int tlen = swb.spt.DataTransferLength > datalen ? datalen : swb.spt.DataTransferLength;
return tlen;
}
-static int spti_inquiry (struct dev_info_ioctl *ciw, int unitnum, uae_u8 *data)
+static int spti_inquiry (struct dev_info_ioctl *ciw, int unitnum, uae_u8 *data, int *datalen)
{
uae_u8 cmd[6] = { 0x12,0,0,0,36,0 }; /* INQUIRY */
int len = sizeof cmd;
-
- do_raw_scsi (ciw, unitnum, cmd, len, data, 256);
+ *datalen = do_raw_scsi (ciw, unitnum, cmd, len, data, 254);
return 1;
}
static int read2048 (struct dev_info_ioctl *ciw, int sector)
{
+ LARGE_INTEGER offset;
+
seterrormode (ciw);
- if (SetFilePointer (ciw->h, sector * 2048, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+ offset.QuadPart = (uae_u64)sector * 2048;
+ if (SetFilePointer (ciw->h, offset.LowPart, &offset.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR) {
reseterrormode (ciw);
return 0;
}
return 0;
ciw->cd_last_pos = sector;
while (cnt-- > 0) {
+ LARGE_INTEGER offset;
gui_flicker_led (LED_CD, unitnum, LED_CD_ACTIVE);
seterrormode (ciw);
- if (SetFilePointer (ciw->h, sector * ciw->di.bytespersector, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+ offset.QuadPart = (uae_u64)sector * ciw->di.bytespersector;
+ if (SetFilePointer (ciw->h, offset.LowPart, &offset.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR) {
reseterrormode (ciw);
if (win32_error (ciw, unitnum, _T("SetFilePointer")) < 0)
continue;
static int sys_cddev_open (struct dev_info_ioctl *ciw, int unitnum)
{
uae_u8 inquiry[256];
+ int datalen;
+
ciw->cdda_volume[0] = 0x7fff;
ciw->cdda_volume[1] = 0x7fff;
ciw->cdda_volume_main = currprefs.sound_volume_cd >= 0 ? currprefs.sound_volume_cd : currprefs.sound_volume;
_tcscpy (ciw->di.vendorid, _T("UAE"));
_stprintf (ciw->di.productid, _T("SCSI CD%d IMG"), unitnum);
- _tcscpy (ciw->di.revision, _T("0.1"));
+ _tcscpy (ciw->di.revision, _T("0.2"));
memset (inquiry, 0, sizeof inquiry);
- if (spti_inquiry (ciw, unitnum, inquiry)) {
+ if (spti_inquiry (ciw, unitnum, inquiry, &datalen)) {
// check also that device type is non-zero and it is removable
- if ((inquiry[0] & 31) && (inquiry[1] & 0x80) && inquiry[8]) {
+ if (datalen >= 36 && (inquiry[0] & 31) && (inquiry[1] & 0x80) && inquiry[8]) {
char tmp[20];
TCHAR *s;
memcpy (tmp, inquiry + 8, 8);
static LRESULT CALLBACK SocketWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if(message >= 0xB000 && message < 0xB000 + MAXPENDINGASYNC * 2) {
-#ifdef TRACING_ENABLED
- write_log (_T("sockmsg(0x%x[%d], 0x%x, 0x%x)\n"), message, (message - 0xb000) / 2, wParam, lParam );
-#endif
+ BSDTRACE((_T("sockmsg(0x%x[%d], 0x%x, 0x%x)\n"), message, (message - 0xb000) / 2, wParam, lParam));
sockmsg(message, wParam, lParam);
return 0;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
-
-
static unsigned int sock_thread2(void *blah)
{
unsigned int result = 0;
wscnt = ++wscounter;
-#ifdef TRACING_ENABLED
+
if (to)
BSDTRACE((_T("sendto(%d,0x%x,%d,0x%x,0x%x,%d):%d-> "),sd,msg,len,flags,to,tolen,wscnt));
else
BSDTRACE((_T("send(%d,0x%x,%d,%d):%d -> "),sd,msg,len,flags,wscnt));
-#endif
+
sd++;
s = getsock(sb,sd);
} else
sb->resultval = -1;
-#ifdef TRACING_ENABLED
if (sb->resultval == -1)
BSDTRACE((_T("sendto failed (%d):%d\n"),sb->sb_errno,wscnt));
else
BSDTRACE((_T("sendto %d:%d\n"),sb->resultval,wscnt));
-#endif
-
}
void host_recvfrom(TrapContext *context, SB, uae_u32 sd, uae_u32 msg, uae_u32 len, uae_u32 flags, uae_u32 addr, uae_u32 addrlen)
wscnt = ++wscounter;
-#ifdef TRACING_ENABLED
if (addr)
BSDTRACE((_T("recvfrom(%d,0x%x,%d,0x%x,0x%x,%d):%d -> "),sd,msg,len,flags,addr,get_long (addrlen),wscnt));
else
BSDTRACE((_T("recv(%d,0x%x,%d,0x%x):%d -> "),sd,msg,len,flags,wscnt));
-#endif
+
sd++;
s = getsock(sb,sd);
} else
sb->resultval = -1;
-#ifdef TRACING_ENABLED
if (sb->resultval == -1)
BSDTRACE((_T("recv failed (%d):%d\n"),sb->sb_errno,wscnt));
else
BSDTRACE((_T("recv %d:%d\n"),sb->resultval,wscnt));
-#endif
-
}
uae_u32 host_shutdown(SB, uae_u32 sd, uae_u32 how)
static void fddebug(const TCHAR *name, uae_u32 nfds, uae_u32 fd)
{
-#ifdef TRACING_ENABLED
+ if (!ISBSDTRACE)
+ return;
if (!nfds)
return;
if (!fd)
out[i] = (v & (1 << i)) ? 'x' : '-';
out[i + 1] = 0;
}
- write_log (_T("%s: %08x %s\n"), name, v, out);
-#endif
+ BSDTRACE((_T("%s: %08x %s\n"), name, v, out));
}
void host_WaitSelect(TrapContext *context, SB, uae_u32 nfds, uae_u32 readfds, uae_u32 writefds, uae_u32 exceptfds, uae_u32 timeout, uae_u32 sigmp)
if ((addr = inet_ntoa(ina)) != NULL) {
scratchbuf = m68k_areg (regs,6) + offsetof(struct UAEBSDBase,scratchbuf);
strncpyha(scratchbuf,addr,SCRATCHBUFSIZE);
-#ifdef TRACING_ENABLED
- TCHAR *s = au (addr);
- BSDTRACE((_T("%s\n"),s));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (addr);
+ BSDTRACE((_T("%s\n"),s));
+ xfree (s);
+ }
return scratchbuf;
} else
SETERRNO;
addr = htonl(inet_addr(cp_rp));
-#ifdef TRACING_ENABLED
- TCHAR *s = au (cp_rp);
- BSDTRACE((_T("inet_addr(%s) -> 0x%08lx\n"),s,addr));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (cp_rp);
+ BSDTRACE((_T("inet_addr(%s) -> 0x%08lx\n"),s,addr));
+ xfree (s);
+ }
return addr;
}
name_rp = (char*)get_real_address (name);
if (addrtype == -1) {
-#ifdef TRACING_ENABLED
- TCHAR *s = au (name_rp);
- BSDTRACE((_T("gethostbyname(%s) -> "),s));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (name_rp);
+ BSDTRACE((_T("gethostbyname(%s) -> "),s));
+ xfree (s);
+ }
// workaround for numeric host "names"
if ((addr = inet_addr(name_rp)) != INADDR_NONE) {
bsdsocklib_seterrno(sb,0);
}
if (sb->hostent) {
- uae_FreeMem(context, sb->hostent, sb->hostentsize);
+ uae_FreeMem(context, sb->hostent, sb->hostentsize, sb->sysbase);
}
- sb->hostent = uae_AllocMem(context, size, 0);
+ sb->hostent = uae_AllocMem(context, size, 0, sb->sysbase);
if (!sb->hostent) {
write_log (_T("BSDSOCK: WARNING - gethostby%s() ran out of Amiga memory ")
put_long (sb->hostent, aptr);
addstr_ansi (&aptr, h->h_name);
-#ifdef TRACING_ENABLED
- TCHAR *s = au (h->h_name);
- BSDTRACE((_T("OK (%s):%d\n"), s, argsp->wscnt));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (h->h_name);
+ BSDTRACE((_T("OK (%s):%d\n"), s, argsp->wscnt));
+ xfree (s);
+ }
+
bsdsocklib_seterrno(sb, 0);
bsdsocklib_setherrno(sb, 0);
if (addr_valid (_T("host_gethostbynameaddr"), name, 1))
name_rp = (char*)get_real_address (name);
-#ifdef TRACING_ENABLED
- TCHAR *s = au (name_rp);
- BSDTRACE((_T("getprotobyname(%s):%d -> "),s, argsp->wscnt));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (name_rp);
+ BSDTRACE((_T("getprotobyname(%s):%d -> "),s, argsp->wscnt));
+ xfree (s);
+ }
argsp->args1 = 1;
argsp->args2 = name;
while (p->p_aliases[numaliases]) size += strlen(p->p_aliases[numaliases++])+5;
if (sb->protoent) {
- uae_FreeMem(context, sb->protoent, sb->protoentsize);
+ uae_FreeMem(context, sb->protoent, sb->protoentsize, sb->sysbase);
}
- sb->protoent = uae_AllocMem(context, size, 0);
+ sb->protoent = uae_AllocMem(context, size, 0, sb->sysbase);
if (!sb->protoent) {
-#ifdef TRACING_ENABLED
- TCHAR *s = au (name_rp);
- write_log (_T("BSDSOCK: WARNING - getprotobyname() ran out of Amiga memory ")
- _T("(couldn't allocate %ld bytes) while returning result of lookup for '%s':%d\n"),
- size, s, argsp->wscnt);
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (name_rp);
+ write_log (_T("BSDSOCK: WARNING - getprotobyname() ran out of Amiga memory ")
+ _T("(couldn't allocate %ld bytes) while returning result of lookup for '%s':%d\n"),
+ size, s, argsp->wscnt);
+ xfree (s);
+ }
bsdsocklib_seterrno(sb,12); // ENOMEM
release_get_thread (tindex);
return;
put_long (sb->protoent + 12 + numaliases * 4,0);
put_long (sb->protoent, aptr);
addstr_ansi (&aptr, p->p_name);
-#ifdef TRACING_ENABLED
- TCHAR *s = au (p->p_name);
- BSDTRACE((_T("OK (%s, %d):%d\n"), s, p->p_proto, argsp->wscnt));
- xfree (s);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *s = au (p->p_name);
+ BSDTRACE((_T("OK (%s, %d):%d\n"), s, p->p_proto, argsp->wscnt));
+ xfree (s);
+ }
bsdsocklib_seterrno (sb,0);
} else {
size += strlen(s->s_aliases[numaliases++])+5;
if (sb->servent) {
- uae_FreeMem(context, sb->servent, sb->serventsize);
+ uae_FreeMem(context, sb->servent, sb->serventsize, sb->sysbase);
}
- sb->servent = uae_AllocMem(context, size, 0);
+ sb->servent = uae_AllocMem(context, size, 0, sb->sysbase);
if (!sb->servent) {
write_log (_T("BSDSOCK: WARNING - getservby%s() ran out of Amiga memory (couldn't allocate %ld bytes):%d\n"), type ? _T("port") : _T("name"), size, argsp->wscnt);
put_long (sb->servent + 12, aptr);
addstr_ansi (&aptr, s->s_proto);
-#ifdef TRACING_ENABLED
- TCHAR *ss = au (s->s_name);
- BSDTRACE((_T("OK (%s, %d):%d\n"), ss, (unsigned short)htons(s->s_port), argsp->wscnt));
- xfree (ss);
-#endif
+ if (ISBSDTRACE) {
+ TCHAR *ss = au (s->s_name);
+ BSDTRACE((_T("OK (%s, %d):%d\n"), ss, (unsigned short)htons(s->s_port), argsp->wscnt));
+ xfree (ss);
+ }
+
bsdsocklib_seterrno(sb, 0);
} else {
write_log (_T("DYNAMIC "));
write_log (_T("\n"));
- write_log (_T("%s: PS=%d.%d VS=%d.%d %d*%d*%d%s VS=%d B=%d%s %d-bit %d\n"),
+ write_log (_T("%s: PS=%d.%d VS=%d.%d %d*%d*%d%s%s VS=%d B=%d%s %d-bit %d\n"),
D3DHEAD,
(d3dCaps.PixelShaderVersion >> 8) & 0xff, d3dCaps.PixelShaderVersion & 0xff,
(d3dCaps.VertexShaderVersion >> 8) & 0xff, d3dCaps.VertexShaderVersion & 0xff,
modeex.Width, modeex.Height,
dpp.FullScreen_RefreshRateInHz,
+ ap->gfx_interlaced ? _T("i") : _T("p"),
dpp.Windowed ? _T("") : _T(" FS"),
vsync, ap->gfx_backbuffers,
ap->gfx_vflip < 0 ? _T("WE") : (ap->gfx_vflip > 0 ? _T("WS") : _T("I")),
if ((d3dCaps.PixelShaderVersion < D3DPS_VERSION(2,0) || !psEnabled || max_texture_w < 2048 || max_texture_h < 2048 || !shaderon) && d3d_ex) {
D3DEX = 0;
write_log (_T("Disabling D3D9Ex\n"));
+ if (d3ddev) {
+ d3ddev->Release ();
+ d3ddev = NULL;
+ }
+ if (d3d) {
+ d3d->Release ();
+ d3d = NULL;
+ }
+ d3ddevex = NULL;
return D3D_init (ahwnd, w_w, w_h, depth, mmult);
}
if (!shaderon)
dxdata.vblank_skip_cnt = 0;
ddrval = IDirectDraw7_SetDisplayMode (dxdata.maindd, width, height, bits, freq, 0);
if (FAILED (ddrval)) {
- write_log (_T("IDirectDraw7_SetDisplayMode: %s\n"), DXError (ddrval));
+ write_log (_T("IDirectDraw7_SetDisplayMode(%d,%d,%d,%d): %s\n"), width, height, bits, freq, DXError (ddrval));
IDirectDraw7_RestoreDisplayMode (dxdata.maindd);
dxdata.fsmodeset = 0;
} else {
#define MAX_PICASSO_MODES 300
#define MAX_REFRESH_RATES 100
+
+#define REFRESH_RATE_RAW 1
+#define REFRESH_RATE_LACE 2
+
struct PicassoResolution
{
struct ScreenResolution res;
int depth; /* depth in bytes-per-pixel */
int residx;
int refresh[MAX_REFRESH_RATES]; /* refresh-rates in Hz */
- int refreshtype[MAX_REFRESH_RATES]; /* 0=normal,1=raw */
+ int refreshtype[MAX_REFRESH_RATES]; /* 0=normal,1=raw,2=lace */
TCHAR name[25];
/* Bit mask of RGBFF_xxx values. */
uae_u32 colormodes;
int rawmode;
- bool lace;
+ bool lace; // all modes lace
};
struct MultiDisplay {
p = (PUCHAR) outBuf;
if (offsetof(STORAGE_DEVICE_DESCRIPTOR, CommandQueueing) > size) {
write_log (_T("too short STORAGE_DEVICE_DESCRIPTOR only %d bytes\n"), size);
- return 1;
+ return -2;
}
if (devDesc->DeviceType != INQ_DASD && devDesc->DeviceType != INQ_ROMD && devDesc->DeviceType != INQ_OPTD) {
write_log (_T("not a direct access device, ignored (type=%d)\n"), devDesc->DeviceType);
- return 1;
+ return -2;
}
if (size > offsetof(STORAGE_DEVICE_DESCRIPTOR, VendorIdOffset) && devDesc->VendorIdOffset && p[devDesc->VendorIdOffset]) {
j = 0;
typedef unsigned long frame_time_t;
extern frame_time_t read_processor_time (void);
+extern uae_u32 read_system_time (void);
#endif
#include "registry.h"
#include "win32gui.h"
-//#define TRACING_ENABLED
+//#define MIDI_TRACING_ENABLED
-#ifdef TRACING_ENABLED
+#ifdef MIDI_TRACING_ENABLED
#define TRACE(x) do { write_log x; } while(0)
#else
#define TRACE(x)
#include "direct3d.h"
#include "clipboard.h"
-#define NOBLITTER 0
-#define NOBLITTER_BLIT 0
+int debug_rtg_blitter = 3;
+
+#define NOBLITTER (0 || !(debug_rtg_blitter & 1))
+#define NOBLITTER_BLIT (0 || !(debug_rtg_blitter & 2))
+
#define USE_HARDWARESPRITE 1
#define P96TRACING_ENABLED 0
#define P96SPRTRACING_ENABLED 0
flags = get_long (ABI + PSSO_BoardInfo_Flags);
flags &= 0xffff0000;
+ if (flags & BIF_NOBLITTER)
+ write_log (_T("P96: Blitter disabled in devs:monitors/uaegfx!\n"));
flags |= BIF_BLITTER | BIF_NOMEMORYMODEMIX;
flags &= ~BIF_HARDWARESPRITE;
if (currprefs.gfx_api && D3D_goodenough () && USE_HARDWARESPRITE) {
hwsprite = 0;
write_log (_T("P96: Hardware sprite support disabled\n"));
}
- if (flags & BIF_NOBLITTER)
- write_log (_T("P96: Blitter disabled in devs:monitors/uaegfx!\n"));
if (currprefs.win32_rtgvblankrate >= -1 && !uaegfx_old)
flags |= BIF_VBLANKINTERRUPT;
if (!(flags & BIF_INDISPLAYCHAIN)) {
flags |= BIF_INDISPLAYCHAIN;
}
put_long (ABI + PSSO_BoardInfo_Flags, flags);
+ if (debug_rtg_blitter != 3)
+ write_log (_T("P96: Blitter mode = %x!\n"), debug_rtg_blitter);
put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 0, planar.width);
put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 2, chunky.width);
vsynctimebase = vsynctimebase_orig;
scaled_sample_evtime = scaled_sample_evtime_orig * mult / 1000.0;
} else if (currprefs.cachesize || currprefs.m68k_speed != 0) {
- vsynctimebase = (long)(((double)vsynctimebase_orig) * mult / 1000.0);
+ vsynctimebase = (int)(((double)vsynctimebase_orig) * mult / 1000.0);
scaled_sample_evtime = scaled_sample_evtime_orig;
} else {
- vsynctimebase = (long)(((double)vsynctimebase_orig) * mult / 1000.0);
+ vsynctimebase = (int)(((double)vsynctimebase_orig) * mult / 1000.0);
scaled_sample_evtime = scaled_sample_evtime_orig;
}
}
extern int rawinput_enabled_hid, rawinput_log;
int log_scsi;
int log_net;
-int log_vsync;
+int log_vsync, debug_vsync_min_delay, debug_vsync_forced_delay;
int uaelib_debug;
int pissoff_value = 15000 * CYCLE_UNIT;
unsigned int fpucontrol;
return read_processor_time_qpf ();
}
+uae_u32 read_system_time (void)
+{
+ return GetTickCount ();
+}
+
#include <process.h>
static volatile int dummythread_die;
static void _cdecl dummythread (void *dummy)
}
write_log (_T("CLOCKFREQ: QPF %.2fMHz (%.2fMHz, DIV=%d)\n"), freq.QuadPart / 1000000.0,
qpfrate / 1000000.0, 1 << qpcdivisor);
- syncbase = (unsigned long)qpfrate;
+ syncbase = (int)qpfrate;
}
static void figure_processor_speed (void)
extern int force_direct_catweasel, sound_mode_skip, maxmem;
extern int pngprint, log_sercon, midi_inbuflen;
extern int vsync_busy_wait_mode;
+extern int debug_rtg_blitter;
+extern int log_bsd;
+extern int inputdevice_logging;
extern DWORD_PTR cpu_affinity, cpu_paffinity;
static DWORD_PTR original_affinity = -1;
log_vsync |= 2;
return 1;
}
+ if (!_tcscmp (arg, _T("bsdlog"))) {
+ log_bsd = 1;
+ return 1;
+ }
if (!_tcscmp (arg, _T("clipboarddebug"))) {
clipboard_debug = 1;
return 1;
if (!np)
return 0;
+ if (!_tcscmp (arg, _T("rtg_blitter"))) {
+ debug_rtg_blitter = getval (np);
+ return 2;
+ }
+ if (!_tcscmp (arg, _T("vsync_min_delay"))) {
+ debug_vsync_min_delay = getval (np);
+ return 2;
+ }
+ if (!_tcscmp (arg, _T("vsync_forced_delay"))) {
+ debug_vsync_forced_delay = getval (np);
+ return 2;
+ }
if (!_tcscmp (arg, _T("inputlog"))) {
rawinput_log = getval (np);
return 2;
}
+ if (!_tcscmp (arg, _T("inputdevicelog"))) {
+ inputdevice_logging = getval (np);
+ return 2;
+ }
if (!_tcscmp (arg, _T("vsyncbusywait"))) {
vsync_busy_wait_mode = getval (np);
return 2;
#define LANG_DLL 1
//#define WINUAEBETA _T("")
-#define WINUAEBETA _T("1")
-#define WINUAEDATE MAKEBD(2012, 5, 13)
+#define WINUAEBETA _T("2")
+#define WINUAEDATE MAKEBD(2012, 5, 18)
#define WINUAEEXTRA _T("")
//#define WINUAEEXTRA _T("AmiKit Preview")
#define WINUAEREV _T("")
static struct winuae_currentmode *currentmode = ¤tmodestruct;
static int wasfullwindow_a, wasfullwindow_p;
-static int vblankbasewait1, vblankbasewait2, vblankbasewait3, vblankbasefull;
+
+static int vblankbasewait1, vblankbasewait2, vblankbasewait3, vblankbasefull, vblankbaseadjust;
static bool vblankbaselace;
static int vblankbaselace_chipset;
static bool vblankthread_oddeven;
}
if (j < MAX_REFRESH_RATES) {
md->DisplayModes[i].refresh[j] = freq;
- md->DisplayModes[i].refreshtype[j] = rawmode;
+ md->DisplayModes[i].refreshtype[j] = (lace ? REFRESH_RATE_LACE : 0) | (rawmode ? REFRESH_RATE_RAW : 0);
md->DisplayModes[i].refresh[j + 1] = 0;
+ if (!lace)
+ md->DisplayModes[i].lace = false;
return;
}
}
while (md->DisplayModes[i].refresh[j] > 0) {
if (j > 0)
write_log (_T(","));
- if (md->DisplayModes[i].refreshtype[j])
- write_log (_T("!%d"), md->DisplayModes[i].refresh[j]);
- else
- write_log (_T("%d"), md->DisplayModes[i].refresh[j]);
+ if (md->DisplayModes[i].refreshtype[j] & REFRESH_RATE_RAW)
+ write_log (_T("!"));
+ write_log (_T("%d"), md->DisplayModes[i].refresh[j]);
+ if (md->DisplayModes[i].refreshtype[j] & REFRESH_RATE_LACE)
+ write_log (_T("i"));
j++;
}
write_log (_T(")\n"));
struct MultiDisplay *md = getdisplay (&currprefs);
struct PicassoResolution *found;
int newh, i, cnt;
- bool preferdouble = 0;
+ bool preferdouble = 0, preferlace = 0;
+ bool lace = false;
if (currprefs.gfx_apmode[0].gfx_refreshrate > 85) {
preferdouble = 1;
+ } else if (currprefs.gfx_apmode[0].gfx_interlaced) {
+ preferlace = 1;
}
if (hz >= 55)
found = NULL;
for (cnt = 0; cnt <= abs (newh - h) + 1 && !found; cnt++) {
for (int dbl = 0; dbl < 2 && !found; dbl++) {
- bool doublecheck = (dbl == 0 && preferdouble) || (dbl == 1 && !preferdouble);
+ bool doublecheck = false;
+ bool lacecheck = false;
+ if (preferdouble && dbl == 0)
+ doublecheck = true;
+ else if (preferlace && dbl == 0)
+ lacecheck = true;
+
for (int extra = 1; extra >= -1 && !found; extra--) {
for (i = 0; md->DisplayModes[i].depth >= 0 && !found; i++) {
struct PicassoResolution *r = &md->DisplayModes[i];
if (r->res.width == w && (r->res.height == newh + cnt || r->res.height == newh - cnt) && r->depth == d) {
int j;
for (j = 0; r->refresh[j] > 0; j++) {
- if ((!doublecheck && r->refresh[j] == hz + extra) || (doublecheck && r->refresh[j] == hz * 2 + extra)) {
- found = r;
- hz = r->refresh[j];
- break;
+ if (doublecheck) {
+ if (r->refreshtype[j] & REFRESH_RATE_LACE)
+ continue;
+ if (r->refresh[j] == hz * 2 + extra) {
+ found = r;
+ hz = r->refresh[j];
+ break;
+ }
+ } else if (lacecheck) {
+ if (!(r->refreshtype[j] & REFRESH_RATE_LACE))
+ continue;
+ if (r->refresh[j] * 2 == hz + extra) {
+ found = r;
+ lace = true;
+ hz = r->refresh[j];
+ break;
+ }
+ } else {
+ if (r->refresh[j] == hz + extra) {
+ found = r;
+ hz = r->refresh[j];
+ break;
+ }
}
}
}
if (currprefs.gfx_apmode[0].gfx_vsync != changed_prefs.gfx_apmode[0].gfx_vsync) {
config_changed = 1;
}
- write_log (_T("refresh rate changed to %d but no matching screenmode found, vsync disabled\n"), hz);
+ write_log (_T("refresh rate changed to %d%s but no matching screenmode found, vsync disabled\n"), hz, lace ? _T("i") : _T("p"));
return false;
} else {
newh = found->res.height;
changed_prefs.gfx_size_fs.height = newh;
changed_prefs.gfx_apmode[0].gfx_refreshrate = hz;
+ changed_prefs.gfx_apmode[0].gfx_interlaced = lace;
if (changed_prefs.gfx_size_fs.height != currprefs.gfx_size_fs.height ||
changed_prefs.gfx_apmode[0].gfx_refreshrate != currprefs.gfx_apmode[0].gfx_refreshrate) {
- write_log (_T("refresh rate changed to %d, new screenmode %dx%d\n"), hz, w, newh);
+ write_log (_T("refresh rate changed to %d%s, new screenmode %dx%d\n"), hz, lace ? _T("i") : _T("p"), w, newh);
config_changed = 1;
}
return true;
}
}
+static int timezeroonevblank (int startline, int endline)
+{
+ int vp;
+ for (;;) {
+ if (!getvblankpos (&vp))
+ return -1;
+ if (vp > endline)
+ break;
+ }
+ for (;;) {
+ if (!getvblankpos (&vp))
+ return -1;
+ if (vp == startline)
+ break;
+ }
+ frame_time_t start = read_processor_time ();
+ for (;;) {
+ if (!getvblankpos (&vp))
+ return -1;
+ if (vp >= endline)
+ break;
+ }
+ frame_time_t end = read_processor_time ();
+ return end - start;
+}
+
static int vblank_wait (void)
{
int vp;
static bool vblanklaceskip (void)
{
if (vblankbaselace_chipset >= 0 && vblankbaselace) {
- if ((vblankbaselace_chipset && !vblankthread_oddeven) || (!vblankbaselace_chipset && vblankthread_oddeven)) {
- write_log (_T("Interlaced frame type mismatch %d<>%d\n"), vblankbaselace_chipset, vblankthread_oddeven);
+ if ((vblankbaselace_chipset && !vblankthread_oddeven) || (!vblankbaselace_chipset && vblankthread_oddeven))
return true;
- }
}
return false;
}
+static bool vblanklaceskip_check (void)
+{
+ int vp = -2;
+ if (!vblanklaceskip ()) {
+// if (vblankbaselace_chipset >= 0)
+// write_log (_T("%d == %d\n"), vblankbaselace_chipset, vblankthread_oddeven);
+ return false;
+ }
+ getvblankpos (&vp);
+ write_log (_T("Interlaced frame type mismatch %d<>%d (%d)\n"), vblankbaselace_chipset, vblankthread_oddeven, vp);
+ return true;
+}
+
static unsigned int __stdcall vblankthread (void *dummy)
{
bool firstvblankbasewait2;
sleep_millis (1);
continue;
}
+
ResetEvent (vblankwaitevent);
if (vp > maxscanline / 2)
vp = maxscanline / 2;
frame_time_t rpt = read_processor_time ();
- vblank_prev_time2 = rpt - (vblankbasefull * vp / maxscanline) / (vblank_skipeveryother ? 2 : 1);
+ vblank_prev_time2 = rpt - (vblankbaseadjust + (vblankbasefull * vp / maxscanline) / (vblank_skipeveryother ? 2 : 1));
vblank_prev_time = vblank_prev_time2;
firstvblankbasewait2 = false;
prevvblankpos = 0;
bool vblank_found_rtg2 = false;
bool vblank_found2 = false;
frame_time_t thread_vblank_time2 = 0;
- int vs = isvsync_chipset ();
// immediate vblank if mismatched frame type
- if (vs < 0 && vblanklaceskip ()) {
+ if (vblanklaceskip_check ()) {
vblank_found2 = true;
vblank_found_chipset = true;
end = true;
+ doflipped = true;
+ thread_vblank_time2 = vblank_prev_time;
} else if (t - vblank_prev_time2 > vblankbasewait2) {
int vp = 0;
bool vb = false;
firstvblankbasewait2 = true;
vblank_getstate (&vb, &vp);
}
- if (!doflipped && !dooddevenskip && ap->gfx_vflip > 0) {
+ if (!doflipped && ap->gfx_vflip > 0) {
doflipevent ();
doflipped = true;
}
ok = vblank_getstate (&vb, &vp);
if (!ok || vb) {
thread_vblank_time2 = t;
- if (vs < 0) {
- vblank_found_chipset = true;
- if (!ap->gfx_vflip) {
- while (!render_ok) {
- if (read_processor_time () - t > vblankbasefull)
- break;
- }
- show_screen ();
- render_ok = false;
- int delay = read_processor_time () - t;
- if (delay < 0)
- delay = 0;
- else if (delay > vblankbasefull)
- delay = 0;
- else if (delay > vblankbasefull * 2 / 3)
- delay = vblankbasefull * 2 / 3;
- vblank_found_flipdelay = delay;
+ vblank_found_chipset = true;
+ if (!ap->gfx_vflip) {
+ while (!render_ok) {
+ if (read_processor_time () - t > vblankbasefull)
+ break;
}
+ show_screen ();
+ render_ok = false;
+ int delay = read_processor_time () - t;
+ if (delay < 0)
+ delay = 0;
+ else if (delay >= vblankbasefull)
+ delay = 0;
+ else if (delay > vblankbasefull * 2 / 3)
+ delay = vblankbasefull * 2 / 3;
+ vblank_found_flipdelay = delay;
}
vblank_found_rtg2 = true;
vblank_found2 = true;
end = true;
}
if (end) {
- if (!dooddevenskip && ap->gfx_vflip > 0 && !doflipped) {
+ if (ap->gfx_vflip > 0 && !doflipped) {
doflipevent ();
doflipped = true;
}
sleep_millis_main (1);
}
prev = vblank_prev_time;
- if (!dooddevenskip) {
+ if (!vblanklaceskip ()) {
int delay = 10;
frame_time_t t = read_processor_time ();
while (delay-- > 0) {
}
}
+bool vsync_isdone (void)
+{
+ return vblank_found_chipset || dooddevenskip;
+}
+
void vsync_busywait_start (void)
{
- if (vblankthread_mode < 0)
- write_log (L"low latency threaded mode but thread is not running!?\n");
- else if (vblankthread_mode != VBLANKTH_ACTIVE_WAIT)
- write_log (L"low latency vsync state mismatch %d\n", vblankthread_mode);
- changevblankthreadmode_fast (VBLANKTH_ACTIVE_START);
+ if (isthreadedvsync ()) {
+ if (vblankthread_mode < 0)
+ write_log (L"low latency threaded mode but thread is not running!?\n");
+ else if (vblankthread_mode != VBLANKTH_ACTIVE_WAIT)
+ write_log (L"low latency vsync state mismatch %d\n", vblankthread_mode);
+ changevblankthreadmode_fast (VBLANKTH_ACTIVE_START);
+ }
}
-bool vsync_busywait_do (int *freetime, bool lace, bool oddeven)
+int vsync_busywait_do (int *freetime, bool lace, bool oddeven)
{
- bool v;
+ int v;
static bool framelost;
int ti;
frame_time_t t;
struct apmode *ap = picasso_on ? &currprefs.gfx_apmode[1] : &currprefs.gfx_apmode[0];
dooddevenskip = false;
-
if (lace)
- vblankbaselace_chipset = oddeven;
+ vblankbaselace_chipset = oddeven == true ? 1 : 0;
else
vblankbaselace_chipset = -1;
return true;
}
- if (log_vsync & 1) {
+ if (0 || (log_vsync & 1)) {
console_out_f(_T("F:%8d M:%8d E:%8d %3d%% (%3d%%) %10d\r"), frame_counted, frame_missed, frame_errors, frame_usage, frame_usage_avg, (t - vblank_prev_time) - vblankbasefull);
+ //write_log(_T("F:%8d M:%8d E:%8d %3d%% (%3d%%) %10d\n"), frame_counted, frame_missed, frame_errors, frame_usage, frame_usage_avg, (t - vblank_prev_time) - vblankbasefull);
}
if (freetime)
if (frame_counted)
frame_usage_avg = frame_usage_total / frame_counted;
- v = false;
+ v = 0;
if (isthreadedvsync ()) {
framelost = false;
- v = true;
+ v = 1;
} else {
- bool doskip = false;
+ int vp;
vblank_flip_delay = 0;
- if (!framelost && t - prevtime > vblankbasefull) {
- framelost = true;
- frame_missed++;
- return true;
- }
-
- if (vblanklaceskip ()) {
- doskip = true;
+ dooddevenskip = false;
+
+ if (vblanklaceskip_check ()) {
+
+ vblank_prev_time = read_processor_time () + vblankbasewait1;
dooddevenskip = true;
- }
+ framelost = true;
+ v = -1;
+
+ } else if (currprefs.turbo_emulation) {
- if (currprefs.turbo_emulation) {
show_screen ();
vblank_prev_time = read_processor_time ();
- return true;
- }
+ framelost = true;
+ v = -1;
+
+ } else {
- if (!doskip) {
- int vp;
while (!framelost && read_processor_time () - prevtime < vblankbasewait1) {
vsync_sleep (false);
}
+
prevvblankpos = 0;
vp = vblank_wait ();
if (vp >= -1) {
if (ap->gfx_vflip != 0) {
show_screen ();
}
+ vblank_prev_time -= vblankbaseadjust;
vblank_prev_time -= (vblankbasefull * vp / maxscanline) / (vblank_skipeveryother ? 2 : 1 );
- v = true;
+
+ v = framelost ? -1 : 1;
}
- } else {
- v = true;
- vblank_prev_time = read_processor_time ();
+
+ framelost = false;
}
- framelost = false;
}
if (v) {
frame_counted++;
- return true;
+ return v;
}
frame_errors++;
- return false;
+ return 0;
}
static struct remembered_vsync *vsyncmemory;
int width, height, depth, rate, mode;
bool rtg, lace;
double remembered_rate, remembered_rate2;
+ int remembered_adjust;
int maxscanline, minscanline, maxvpos;
};
tsum = rval = rv->remembered_rate;
maxscanline = rv->maxscanline;
minscanline = rv->minscanline;
+ vblankbaseadjust = rv->remembered_adjust;
maxvpos = rv->maxvpos;
lace = rv->lace;
waitonly = true;
flipevent2 = CreateEvent (NULL, FALSE, FALSE, NULL);
vblankwaitevent = CreateEvent (NULL, FALSE, FALSE, NULL);
_beginthreadex (NULL, 0, flipthread, 0, 0, &th);
- write_log (_T("Low latency vsync thread started\n"));
} else {
changevblankthreadmode (VBLANKTH_CALIBRATE);
}
if (cnt >= total)
break;
}
+ vblankbaseadjust = 0;
+ if (minscanline == 1)
+ vblankbaseadjust = timezeroonevblank (-1, 1);
changevblankthreadmode (VBLANKTH_IDLE);
vblankbasewait2 = (syncbase / tsum2) * 55 / 100;
vblankbasewait3 = (syncbase / tsum2) * 99 / 100 - syncbase / (250 * (vblank_skipeveryother ? 1 : 2)); // at least 2ms before vblank
vblankbaselace = lace;
- write_log (_T("VSync %s: %.6fHz/%.1f=%.6fHz. MinV=%d MaxV=%d%s Units=%d %.1f%%\n"),
+ if (vblankbaseadjust < 0)
+ vblankbaseadjust = 0;
+ else if (vblankbaseadjust > vblankbasefull / 10)
+ vblankbaseadjust = vblankbasefull / 10;
+
+ write_log (_T("VSync %s: %.6fHz/%.1f=%.6fHz. MinV=%d MaxV=%d%s Adj=%d Units=%d %.1f%%\n"),
waitonly ? _T("remembered") : _T("calibrated"), tsum, div, tsum2,
- minscanline, maxvpos, lace ? _T("i") : _T(""), vblankbasefull,
+ minscanline, maxvpos, lace ? _T("i") : _T(""), vblankbaseadjust, vblankbasefull,
vblankbasewait3 * 100 / (syncbase / tsum2));
remembered_vblank = tsum;
vblank_prev_time = read_processor_time ();
rv->rtg = picasso_on;
rv->remembered_rate = tsum;
rv->remembered_rate2 = tsum2;
+ rv->remembered_adjust = vblankbaseadjust;
rv->maxscanline = maxscanline;
rv->minscanline = minscanline;
rv->maxvpos = maxvpos;
WIN32GUI_LoadUIString (IDS_VSYNC_DEFAULT, txt, sizeof (txt) / sizeof (TCHAR));
SendDlgItemMessage(hDlg, IDC_REFRESHRATE, CB_ADDSTRING, 0, (LPARAM)txt);
for (i = 0; i < index; i++) {
+ bool lace = (storedrefreshrates[i].type & REFRESH_RATE_LACE) != 0;
freq = storedrefreshrates[i].rate;
if (freq < 0) {
freq = -freq;
} else {
_stprintf (hz, L"%dHz", freq);
}
- if (freq == 50 || freq == 100)
+ if (freq == 50 || freq == 100 || (freq * 2 == 50 && lace))
_tcscat (hz, L" PAL");
- if (freq == 60 || freq == 120)
+ if (freq == 60 || freq == 120 || (freq * 2 == 60 && lace))
_tcscat (hz, L" NTSC");
- if (storedrefreshrates[i].type)
+ if (lace) {
+ TCHAR tmp[10];
+ _stprintf (tmp, L" (%di)", freq * 2);
+ _tcscat (hz, tmp);
+ }
+ if (storedrefreshrates[i].type & REFRESH_RATE_RAW)
_tcscat (hz, L" (*)");
if (abs (workprefs.gfx_apmode[0].gfx_refreshrate) == freq)
_tcscpy (hz2, hz);
} else {
posn1--;
workprefs.gfx_apmode[0].gfx_refreshrate = storedrefreshrates[posn1].rate;
+ workprefs.gfx_apmode[0].gfx_interlaced = (storedrefreshrates[posn1].type & REFRESH_RATE_LACE) != false;
}
values_to_displaydlg (hDlg);
} else if (LOWORD (wParam) == IDC_DA_MODE) {
- hdd from command line
- no-buffer tearing updates
+Beta 2:
+
+- Missing harddrive in harddrive dialog if any device returned "too short STORAGE_DEVICE_DESCRIPTOR only x bytes". (2.4.0)
+- D3D crashed if Vista or newer and D3D9Ex couldn't be used (shaders didn't load for reason for example) (2.3.something)
+- Vsync dynamic adjustment algoritm updated.
+- Added vsync debugging command line options:
+ -vsync_min_delay <val>: val is value from 1 to 90, minimum guaranteed extra time left for
+ display rendering. Automatic dynamic adjustment system can still use higher values if needed.
+ -vsync_forced_delay <val>: val is forced extra time, dynamic adjustment is disabled.
+ <val> is percentage of total frame time, the bigger the value, the less chance for tearing and slower
+ CPU emulation performance (if fastest possible mode).
+ Above Parameters work in low latency no buffer mode and in all legacy vsync modes.
+ -vsynclog shows frame counts (total, missed, errors, time waited for frame relative to total frame,
+ average of previous value, current frame time difference) Low latency only parameter.
+ -vsynclog2 starts logging current adjustment parameters. Mostly undocumented values except last 4:
+ current adjustment value, time/scanline, total frame time, adjustment percentage value.
+ Note that time unit is internal PC time counter (Rate can be seen in winuaebootlog.txt)
+- Added -rtg_blitter <val> command line option (0 = disable native RTG blitter acceleration code)
+- Show more correct vertical and horizontal frequency in display mode change log line.
+- Added -bsdlog command line parameter, enables full bsdsocket emulation logging. (This was previously
+ compile-time option)
+- Support PC screen resolutions that have both progressive and interlaced modes.
+- PC interlaced modes work in D3D mode, fixes blank screen.
+- Added 50i/60i switching support to autovsync.
+- Added timing compensation to low latency vsync for some drivers (nvidia only?) that don't count any
+ lines inside vblank period. (MinV=1 in the log)
+- IOCTL 32-bit overflow fix, CDFS DVD read error when accessing data outside of first 2G.
+- Built-in CD image mounter 32-bit image size restrictions removed.
+
+Beta 1:
- Autovsync 50/60Hz also accepts 100/120Hz modes if available, supports also refresh rates +-1 from nominal.
- CD32: CD command receive DMA emulation correctly emulated, TOC read hack removed.
int console_logging = 0;
static int debugger_type = -1;
extern BOOL debuggerinitializing;
+extern int lof_store;
int always_flush_log = 1;
#define WRITE_LOG_BUF_SIZE 4096
_stprintf (p, _T("%03d"), tb.millitm);
p += _tcslen (p);
if (vsync_counter != 0xffffffff)
- _stprintf (p, _T(" [%d %03dx%03d]"), vsync_counter, current_hpos (), vpos);
+ _stprintf (p, _T(" [%d %03d%s%03d]"), vsync_counter, current_hpos (), lof_store ? _T("-") : _T("="), vpos);
_tcscat (p, _T(": "));
return out;
}
projects / francis / winuae.git / commitdiff