pc8801コア互換層の段階更新（FDD/API受け皿拡張）

Source/ePC-8801MA/vm/device.h

@@ -624,16 +624,72 @@ class DEVICE
 		}
 		event_manager->set_frames_per_sec(frames);
 	}
-	virtual void set_lines_per_frame(int lines)
-	{
-		if(event_manager == NULL) {
-			event_manager = vm->first_device->next_device;
-		}
-		event_manager->set_lines_per_frame(lines);
-	}
-#ifdef SDL
-	virtual void abort_main_cpu()
-	{
+	virtual void set_lines_per_frame(int lines)
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		event_manager->set_lines_per_frame(lines);
+	}
+	virtual int get_lines_per_frame()
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_lines_per_frame();
+	}
+	virtual void update_event_in_op(int clock)
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		event_manager->update_event_in_op(clock);
+	}
+	virtual uint32 get_event_remaining_clock(int register_id)
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_event_remaining_clock(register_id);
+	}
+	virtual double get_event_remaining_usec(int register_id)
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_event_remaining_usec(register_id);
+	}
+	virtual uint32 get_passed_clock_since_vline()
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_passed_clock_since_vline();
+	}
+	virtual double get_passed_usec_since_vline()
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_passed_usec_since_vline();
+	}
+	virtual int get_cur_vline()
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_cur_vline();
+	}
+	virtual int get_cur_vline_clocks()
+	{
+		if(event_manager == NULL) {
+			event_manager = vm->first_device->next_device;
+		}
+		return event_manager->get_cur_vline_clocks();
+	}
+#ifdef SDL
+	virtual void abort_main_cpu()
+	{
 		if(event_manager == NULL) {
 			event_manager = vm->first_device->next_device;
 		}

Source/ePC-8801MA/vm/event.cpp

@@ -107,12 +107,14 @@ void EVENT::reset()
 	single_exec_clock = 0;
 #endif // SDL
 
-	event_remain = 0;
-	cpu_remain = cpu_accum = cpu_done = 0;
-
-	// reset sound
-	if(sound_buffer) {
-		memset(sound_buffer, 0, sound_samples * sizeof(uint16) * 2);
+	event_remain = 0;
+	cpu_remain = cpu_accum = cpu_done = 0;
+	cur_vline = 0;
+	vline_start_clock = current_clock();
+
+	// reset sound
+	if(sound_buffer) {
+		memset(sound_buffer, 0, sound_samples * sizeof(uint16) * 2);
 	}
 	if(sound_tmp) {
 		memset(sound_tmp, 0, sound_tmp_samples * sizeof(int32) * 2);
@@ -192,16 +194,19 @@ void EVENT::drive()
 	for(int i = 0; i < frame_event_count; i++) {
 		frame_event[i]->event_frame();
 	}
-#ifdef SDL
-	for(int v = 0; v < lines_per_frame;) {
-		int exec_lines;
-		int min_event_clock;
-		int main_cpu_exec;
-		int sub_cpu_exec;
-		int sub_cpu_done;
-
-		// get execute lines from PC88::event_vline()
-		exec_lines = vline_event[0]->event_vline(v);
+#ifdef SDL
+	for(int v = 0; v < lines_per_frame;) {
+		int exec_lines;
+		int min_event_clock;
+		int main_cpu_exec;
+		int sub_cpu_exec;
+		int sub_cpu_done;
+
+		cur_vline = v;
+		vline_start_clock = current_clock();
+
+		// get execute lines from PC88::event_vline()
+		exec_lines = vline_event[0]->event_vline(v);
 
 		if (exec_lines == 1) {
 			// V-DISP
@@ -304,12 +309,15 @@ void EVENT::drive()
 
 	// mix sound at the end of frame
 	mix_sound_block();
-#else
-	for(int v = 0; v < lines_per_frame; v++) {
-		// run virtual machine per line
-		for(int i = 0; i < vline_event_count; i++) {
-			vline_event[i]->event_vline(v, vclocks[v]);
-		}
+#else
+	for(int v = 0; v < lines_per_frame; v++) {
+		cur_vline = v;
+		vline_start_clock = current_clock();
+
+		// run virtual machine per line
+		for(int i = 0; i < vline_event_count; i++) {
+			vline_event[i]->event_vline(v, vclocks[v]);
+		}
 
 		if(event_remain < 0) {
 			if(-event_remain > vclocks[v]) {
@@ -361,11 +369,38 @@ void EVENT::drive()
 			}
 		}
 	}
-#endif // SDL
-}
-
-void EVENT::update_event(int clock)
-{
+#endif // SDL
+}
+
+void EVENT::update_event_in_op(int clock)
+{
+#ifdef SDL
+	// SDL path updates events in drive(). Keep this as a compatibility no-op.
+	(void)clock;
+#else
+	if(clock <= 0) {
+		return;
+	}
+	cpu_remain -= clock;
+	cpu_accum += clock;
+	int event_done = cpu_accum >> power;
+	cpu_accum -= event_done << power;
+
+	if(event_done > 0) {
+		if(event_remain > 0) {
+			if(event_done > event_remain) {
+				update_event(event_remain);
+			} else {
+				update_event(event_done);
+			}
+		}
+		event_remain -= event_done;
+	}
+#endif // SDL
+}
+
+void EVENT::update_event(int clock)
+{
 #ifdef SDL
 	event_t *event_handle;
 
@@ -518,14 +553,24 @@ uint32 EVENT::passed_clock(uint32 prev)
 	return (current > prev) ? current - prev : current + (0xffffffff - prev) + 1;
 }
 
-double EVENT::passed_usec(uint32 prev)
-{
-	return 1000000.0 * passed_clock(prev) / d_cpu[0].cpu_clocks;
-}
-
-uint32 EVENT::get_cpu_pc(int index)
-{
-	return d_cpu[index].device->get_pc();
+double EVENT::passed_usec(uint32 prev)
+{
+	return 1000000.0 * passed_clock(prev) / d_cpu[0].cpu_clocks;
+}
+
+uint32 EVENT::get_passed_clock_since_vline()
+{
+	return passed_clock(vline_start_clock);
+}
+
+double EVENT::get_passed_usec_since_vline()
+{
+	return passed_usec(vline_start_clock);
+}
+
+uint32 EVENT::get_cpu_pc(int index)
+{
+	return d_cpu[index].device->get_pc();
 }
 
 void EVENT::register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id)
@@ -750,27 +795,61 @@ void EVENT::cancel_event(DEVICE* device, int register_id)
 	}
 }
 
-void EVENT::register_frame_event(DEVICE* dev)
-{
-	if(frame_event_count < MAX_EVENT) {
-		frame_event[frame_event_count++] = dev;
-	} else {
-#ifdef _DEBUG_LOG
+void EVENT::register_frame_event(DEVICE* dev)
+{
+	if(frame_event_count < MAX_EVENT) {
+		for(int i = 0; i < frame_event_count; i++) {
+			if(frame_event[i] == dev) {
+				return;
+			}
+		}
+		frame_event[frame_event_count++] = dev;
+	} else {
+#ifdef _DEBUG_LOG
 		emu->out_debug_log(_T("EVENT: too many frame events !!!\n"));
 #endif
 	}
 }
 
-void EVENT::register_vline_event(DEVICE* dev)
-{
-	if(vline_event_count < MAX_EVENT) {
-		vline_event[vline_event_count++] = dev;
-	} else {
-#ifdef _DEBUG_LOG
+void EVENT::register_vline_event(DEVICE* dev)
+{
+	if(vline_event_count < MAX_EVENT) {
+		for(int i = 0; i < vline_event_count; i++) {
+			if(vline_event[i] == dev) {
+				return;
+			}
+		}
+		vline_event[vline_event_count++] = dev;
+	} else {
+#ifdef _DEBUG_LOG
 		emu->out_debug_log(_T("EVENT: too many vline events !!!\n"));
 #endif
-	}
-}
+	}
+}
+
+uint32 EVENT::get_event_remaining_clock(int register_id)
+{
+	if(0 <= register_id && register_id < MAX_EVENT) {
+		event_t *event_handle = &event[register_id];
+		if(event_handle->active) {
+#ifdef SDL
+			if(event_handle->remain_clock > event_handle->passed_clock) {
+				return (event_handle->remain_clock - event_handle->passed_clock + 0x3ff) >> 10;
+			}
+#else
+			if(event_handle->expired_clock > event_clocks) {
+				return (uint32)(event_handle->expired_clock - event_clocks);
+			}
+#endif // SDL
+		}
+	}
+	return 0;
+}
+
+double EVENT::get_event_remaining_usec(int register_id)
+{
+	return 1000000.0 * get_event_remaining_clock(register_id) / d_cpu[0].cpu_clocks;
+}
 
 #ifdef SDL
 void EVENT::adjust_event(int register_id, double usec)