2007-05-29 03:06:33 +00:00
|
|
|
//
|
|
|
|
// Apple 2 SDL Portable Apple Emulator
|
|
|
|
//
|
2013-09-28 23:15:54 +00:00
|
|
|
// by James Hammons
|
2018-09-10 03:47:51 +00:00
|
|
|
// © 2018 Underground Software
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
2017-06-22 03:57:57 +00:00
|
|
|
// Parts loosely inspired by AppleWin by Tom Charlesworth which was based on
|
|
|
|
// AppleWin by Oliver Schmidt which was based on AppleWin by Michael O'Brien.
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// :-) Some parts (mainly TV rendering) are derived from ApplePC. Too bad it
|
2017-06-22 03:57:57 +00:00
|
|
|
// was closed source--it could have been *the* premier Apple II emulator out
|
|
|
|
// there.
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
2013-09-28 23:15:54 +00:00
|
|
|
// JLH = James Hammons <jlhamm@acm.org>
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
|
|
|
// WHO WHEN WHAT
|
2017-06-02 02:42:15 +00:00
|
|
|
// --- ---------- -----------------------------------------------------------
|
2007-05-29 03:06:33 +00:00
|
|
|
// JLH 11/12/2005 Initial port to SDL
|
2009-01-22 22:12:49 +00:00
|
|
|
// JLH 11/18/2005 Wired up graphic soft switches
|
2007-05-29 03:06:33 +00:00
|
|
|
// JLH 12/02/2005 Setup timer subsystem for more accurate time keeping
|
|
|
|
// JLH 12/12/2005 Added preliminary state saving support
|
2013-09-28 23:15:54 +00:00
|
|
|
// JLH 09/24/2013 Added //e support
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
|
|
|
|
|
|
|
// STILL TO DO:
|
|
|
|
//
|
|
|
|
// - Port to SDL [DONE]
|
|
|
|
// - Weed out unneeded functions [DONE]
|
|
|
|
// - Disk I/O [DONE]
|
2013-09-28 23:15:54 +00:00
|
|
|
// - 128K IIe related stuff [DONE]
|
2018-09-10 03:47:51 +00:00
|
|
|
// - State loading/saving [DONE]
|
|
|
|
// - GUI goodies
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
2017-06-22 03:57:57 +00:00
|
|
|
// BUGS:
|
|
|
|
//
|
|
|
|
// - Having a directory in the ${disks} directory causes a segfault in floppy
|
|
|
|
//
|
2007-05-29 03:06:33 +00:00
|
|
|
|
|
|
|
#include "apple2.h"
|
|
|
|
|
2013-09-09 02:18:23 +00:00
|
|
|
#include <SDL2/SDL.h>
|
2007-05-29 03:06:33 +00:00
|
|
|
#include <fstream>
|
|
|
|
#include <iomanip>
|
|
|
|
#include <iostream>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2017-06-05 03:28:52 +00:00
|
|
|
#include <string>
|
2007-05-29 03:06:33 +00:00
|
|
|
#include <time.h>
|
2019-02-26 04:06:55 +00:00
|
|
|
#include "firmware/apple2-fw.h"
|
|
|
|
#include "firmware/apple2e-enh.h"
|
|
|
|
#include "firmware/firmware.h"
|
2019-02-25 22:34:27 +00:00
|
|
|
#include "floppydrive.h"
|
|
|
|
#include "harddrive.h"
|
2007-05-29 03:06:33 +00:00
|
|
|
#include "log.h"
|
2017-06-05 03:28:52 +00:00
|
|
|
#include "mmu.h"
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
#include "mockingboard.h"
|
2007-05-29 03:06:33 +00:00
|
|
|
#include "settings.h"
|
2017-06-05 03:28:52 +00:00
|
|
|
#include "sound.h"
|
2007-05-29 03:06:33 +00:00
|
|
|
#include "timing.h"
|
2017-06-05 03:28:52 +00:00
|
|
|
#include "video.h"
|
2017-06-22 03:57:57 +00:00
|
|
|
#include "gui/diskselector.h"
|
2019-04-17 03:29:58 +00:00
|
|
|
#include "gui/config.h"
|
|
|
|
#include "gui/gui.h"
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2009-02-16 16:22:33 +00:00
|
|
|
// Debug and misc. defines
|
|
|
|
|
|
|
|
#define THREADED_65C02
|
2009-02-24 15:32:01 +00:00
|
|
|
#define CPU_THREAD_OVERFLOW_COMPENSATION
|
2013-09-19 00:03:09 +00:00
|
|
|
#define DEBUG_LC
|
2009-07-09 01:37:07 +00:00
|
|
|
//#define CPU_CLOCK_CHECKING
|
2013-09-19 00:03:09 +00:00
|
|
|
//#define THREAD_DEBUGGING
|
|
|
|
#define SOFT_SWITCH_DEBUGGING
|
2007-05-29 03:06:33 +00:00
|
|
|
|
|
|
|
// Global variables
|
|
|
|
|
2014-03-27 17:46:00 +00:00
|
|
|
uint8_t ram[0x10000], rom[0x10000]; // RAM & ROM spaces
|
|
|
|
uint8_t ram2[0x10000]; // Auxillary RAM
|
|
|
|
V65C02REGS mainCPU; // v65C02 execution context
|
2013-09-19 00:03:09 +00:00
|
|
|
uint8_t appleType = APPLE_TYPE_IIE;
|
2014-03-27 17:46:00 +00:00
|
|
|
bool powerStateChangeRequested = false;
|
2017-06-22 03:57:57 +00:00
|
|
|
uint64_t frameCycleStart;
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
uint64_t frameTicks = 0;
|
|
|
|
uint64_t frameTime[60];
|
|
|
|
uint32_t frameTimePtr = 0;
|
|
|
|
|
2017-06-22 03:57:57 +00:00
|
|
|
// Exported variables
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2013-09-28 23:15:54 +00:00
|
|
|
uint8_t lastKeyPressed = 0;
|
|
|
|
bool keyDown = false;
|
|
|
|
bool openAppleDown = false;
|
|
|
|
bool closedAppleDown = false;
|
|
|
|
bool store80Mode = false;
|
|
|
|
bool vbl = false;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
bool intCXROM = false;
|
2013-09-28 23:15:54 +00:00
|
|
|
bool slotC3ROM = false;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
bool intC8ROM = false;
|
2013-09-28 23:15:54 +00:00
|
|
|
bool ramrd = false;
|
|
|
|
bool ramwrt = false;
|
|
|
|
bool altzp = false;
|
|
|
|
bool ioudis = true;
|
2013-09-19 00:03:09 +00:00
|
|
|
bool dhires = false;
|
2014-03-27 17:46:00 +00:00
|
|
|
// Language card state (ROM read, no write)
|
|
|
|
uint8_t lcState = 0x02;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
uint8_t blinkTimer = 0;
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2014-03-27 17:46:00 +00:00
|
|
|
static bool running = true; // Machine running state flag...
|
2018-09-10 03:47:51 +00:00
|
|
|
static uint64_t startTicks;
|
2013-09-23 16:05:10 +00:00
|
|
|
static bool pauseMode = false;
|
2013-10-08 21:55:07 +00:00
|
|
|
static bool fullscreenDebounce = false;
|
2017-06-05 03:28:52 +00:00
|
|
|
static bool resetKeyDown = false;
|
2017-06-06 12:42:55 +00:00
|
|
|
static int8_t hideMouseTimeout = 60;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
|
|
|
// Vars to handle the //e's 2-key rollover
|
|
|
|
static SDL_Keycode keysHeld[2];
|
|
|
|
static uint8_t keysHeldAppleCode[2];
|
|
|
|
static uint8_t keyDownCount = 0;
|
2017-06-06 12:42:55 +00:00
|
|
|
static uint8_t keyDelay = 0;
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2017-06-02 02:42:15 +00:00
|
|
|
// Local functions
|
2007-05-29 03:06:33 +00:00
|
|
|
|
|
|
|
static void SaveApple2State(const char * filename);
|
|
|
|
static bool LoadApple2State(const char * filename);
|
2014-03-27 17:46:00 +00:00
|
|
|
static void ResetApple2State(void);
|
2018-09-10 03:47:51 +00:00
|
|
|
static void AppleTimer(uint16_t);
|
2007-05-29 03:06:33 +00:00
|
|
|
|
|
|
|
// Local timer callback functions
|
|
|
|
|
|
|
|
static void FrameCallback(void);
|
|
|
|
static void BlinkTimer(void);
|
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
#ifdef THREADED_65C02
|
|
|
|
// Test of threaded execution of 6502
|
|
|
|
static SDL_Thread * cpuThread = NULL;
|
|
|
|
static SDL_cond * cpuCond = NULL;
|
2009-02-24 15:32:01 +00:00
|
|
|
static SDL_sem * mainSem = NULL;
|
2009-02-11 05:12:55 +00:00
|
|
|
static bool cpuFinished = false;
|
|
|
|
|
2013-09-19 00:03:09 +00:00
|
|
|
// NB: Apple //e Manual sez 6502 is running @ 1,022,727 Hz
|
2017-06-22 03:57:57 +00:00
|
|
|
// This is a lie. At the end of each 65 cycle line, there is an elongated
|
|
|
|
// cycle (the so-called 'long' cycle) that throws the calcs out of whack.
|
2018-09-10 03:47:51 +00:00
|
|
|
// So actually, it's supposed to be 1,020,484.32 Hz
|
2013-09-19 00:03:09 +00:00
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
// Let's try a thread...
|
2017-06-02 02:42:15 +00:00
|
|
|
//
|
|
|
|
// Here's how it works: Execute 1 frame's worth, then sleep. Other stuff wakes
|
2017-06-05 03:28:52 +00:00
|
|
|
// it up.
|
2017-06-02 02:42:15 +00:00
|
|
|
//
|
2018-09-10 03:47:51 +00:00
|
|
|
static uint32_t sampleCount;
|
|
|
|
static uint64_t sampleClock, lastSampleClock;
|
2009-02-11 05:12:55 +00:00
|
|
|
int CPUThreadFunc(void * data)
|
|
|
|
{
|
|
|
|
// Mutex must be locked for conditional to work...
|
|
|
|
// Also, must be created in the thread that uses it...
|
|
|
|
SDL_mutex * cpuMutex = SDL_CreateMutex();
|
|
|
|
|
2009-02-16 16:22:33 +00:00
|
|
|
#ifdef CPU_THREAD_OVERFLOW_COMPENSATION
|
2018-09-10 03:47:51 +00:00
|
|
|
// float overflow = 0.0;
|
2009-02-16 16:22:33 +00:00
|
|
|
#endif
|
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
do
|
|
|
|
{
|
2018-09-10 03:47:51 +00:00
|
|
|
uint64_t cpuFrameTickStart = SDL_GetPerformanceCounter();
|
|
|
|
uint64_t oldClock = mainCPU.clock;
|
|
|
|
sampleCount = 0;
|
|
|
|
sampleClock = lastSampleClock = mainCPU.clock;
|
2009-02-24 15:32:01 +00:00
|
|
|
// decrement mainSem...
|
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: SDL_SemWait(mainSem);\n");
|
|
|
|
#endif
|
2014-04-01 13:47:16 +00:00
|
|
|
SDL_SemWait(mainSem);
|
2009-02-24 15:32:01 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// There are exactly 800 slices of 21.333 cycles per frame, so it works
|
|
|
|
// out evenly.
|
2017-06-22 03:57:57 +00:00
|
|
|
// [Actually, seems it's 786 slices of 21.666 cycles per frame]
|
|
|
|
|
|
|
|
// Set our frame cycle counter to the correct # of cycles at the start
|
|
|
|
// of this frame
|
|
|
|
frameCycleStart = mainCPU.clock - mainCPU.overflow;
|
2013-09-11 15:00:36 +00:00
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: Execute65C02(&mainCPU, cycles);\n");
|
|
|
|
#endif
|
2018-09-10 03:47:51 +00:00
|
|
|
for(int i=0; i<262; i++)
|
2013-09-11 15:00:36 +00:00
|
|
|
{
|
2017-06-05 03:28:52 +00:00
|
|
|
// If the CTRL+Reset key combo is being held, make sure the RESET
|
|
|
|
// line stays asserted:
|
|
|
|
if (resetKeyDown)
|
|
|
|
mainCPU.cpuFlags |= V65C02_ASSERT_LINE_RESET;
|
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
Execute65C02(&mainCPU, 65);
|
2013-09-24 14:09:40 +00:00
|
|
|
|
2017-06-22 03:57:57 +00:00
|
|
|
// According to "Understanding The Apple IIe", VBL asserted after
|
|
|
|
// the last byte of the screen is read and let go on the first read
|
|
|
|
// of the first byte of the screen. We now know that the screen
|
|
|
|
// starts on line #6 and ends on line #197 (of the vertical
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// counter--actual VBLANK proper happens on lines 230 thru 233).
|
2018-09-10 03:47:51 +00:00
|
|
|
vbl = ((i >= 6) && (i <= 197) ? true : false);
|
2013-09-11 15:00:36 +00:00
|
|
|
}
|
2018-09-10 03:47:51 +00:00
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
//WriteLog("*** Frame ran for %d cycles (%.3lf µs, %d samples).\n", mainCPU.clock - oldClock, ((double)(SDL_GetPerformanceCounter() - cpuFrameTickStart) * 1000000.0) / (double)SDL_GetPerformanceFrequency(), sampleCount);
|
2018-09-10 03:47:51 +00:00
|
|
|
// frameTicks = ((SDL_GetPerformanceCounter() - startTicks) * 1000) / SDL_GetPerformanceFrequency();
|
2017-06-22 03:57:57 +00:00
|
|
|
/*
|
|
|
|
Other timings from UTA2E:
|
|
|
|
Power-up reset 32.6 msec / 512 horizontal scans
|
|
|
|
Flash cycle 1.87 Hz / Vertical freq./32
|
|
|
|
Delay before auto repeat 534-801 msec / 32-48 vertical scans
|
|
|
|
Auto repeat frequency 15 Hz / Vertical freq./4
|
2018-09-10 03:47:51 +00:00
|
|
|
Vertical frequency 59.94 Hz (actually, 59.92 Hz [59.92274339401])
|
|
|
|
Horizontal frequency 15,734 Hz (actually, 15700 Hz)
|
|
|
|
1 NTSC frame = 17030 cycles (N.B.: this works out to 1021800 cycles per sec.)
|
|
|
|
NTSC clock frequency ("composite" freq.) is 1.02048432 MHz, which is 14.31818 x (65 / (65 x 14 + 2)) MHz.
|
2017-06-22 03:57:57 +00:00
|
|
|
1 line = 65 cycles
|
|
|
|
70 blank lines for top margin, 192 lines for screen, (35 & 35?)
|
|
|
|
VA-C,V0-5 is upcounter starting at 011111010 ($FA) to 111111111 ($1FF)
|
|
|
|
Horizontal counter is upcounter resets to 0000000, then jumps to 1000000 &
|
|
|
|
counts up to 1111111 (bit 7 is Horizontal Preset Enable, which resets the counter when it goes low, the rest are H0-5)
|
|
|
|
|
|
|
|
pg. 3-24 says one cycle before VBL the counters will be at
|
|
|
|
010111111/1111111 (that doesn't look right to me...)
|
|
|
|
|
|
|
|
Video address bits:
|
|
|
|
|
|
|
|
A0 <- H0
|
|
|
|
A1 <- H1
|
|
|
|
A2 <- H2
|
|
|
|
A3 <- SUM-A3
|
|
|
|
A4 <- SUM-A4
|
|
|
|
A5 <- SUM-A5
|
|
|
|
A6 <- SUM-A6
|
|
|
|
A7 <- V0
|
|
|
|
A8 <- V1
|
|
|
|
A9 <- V2
|
|
|
|
|
|
|
|
SUMS are calculated like so:
|
|
|
|
|
|
|
|
1 1 0 1
|
|
|
|
H5 H4 H3
|
|
|
|
V4 V3 V4 V3
|
|
|
|
------------------------------
|
|
|
|
SUM-A6 SUM-A5 SUM-A4 SUM-A3
|
|
|
|
|
|
|
|
In TEXT mode, A10 == (80STORE' * PAGE2)', A11 == 80STORE' * PAGE2
|
|
|
|
A12-A15 == 0
|
|
|
|
|
|
|
|
In HIRES mode, A13 == (PAGE2 * 80STORE')', A14 == PAGE2 * 80STORE'
|
|
|
|
A10 == VA, A11 == VB, A12 == VC, A15 == 0
|
|
|
|
|
|
|
|
N.B.: VA-C are lower bits than V5-0
|
|
|
|
|
|
|
|
HC, from 00, 0 to 23 is the HBL interval, with horizontal retrace occuring between cycles 8 and 11.
|
|
|
|
VC, from line 0-5 and 198-261 is the VBL interval, with vertical retrace occuring between lines 230-233
|
|
|
|
|
|
|
|
*/
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2009-02-24 15:32:01 +00:00
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: SDL_mutexP(cpuMutex);\n");
|
|
|
|
#endif
|
|
|
|
SDL_mutexP(cpuMutex);
|
2017-06-05 03:28:52 +00:00
|
|
|
// increment mainSem...
|
2009-02-24 15:32:01 +00:00
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: SDL_SemPost(mainSem);\n");
|
|
|
|
#endif
|
2013-09-28 23:15:54 +00:00
|
|
|
SDL_SemPost(mainSem);
|
2009-02-24 15:32:01 +00:00
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: SDL_CondWait(cpuCond, cpuMutex);\n");
|
|
|
|
#endif
|
2009-02-16 16:22:33 +00:00
|
|
|
SDL_CondWait(cpuCond, cpuMutex);
|
2009-02-24 15:32:01 +00:00
|
|
|
|
|
|
|
#ifdef THREAD_DEBUGGING
|
|
|
|
WriteLog("CPU: SDL_mutexV(cpuMutex);\n");
|
2009-02-16 16:22:33 +00:00
|
|
|
#endif
|
2009-02-11 05:12:55 +00:00
|
|
|
SDL_mutexV(cpuMutex);
|
|
|
|
}
|
|
|
|
while (!cpuFinished);
|
|
|
|
|
2009-02-24 15:32:01 +00:00
|
|
|
SDL_DestroyMutex(cpuMutex);
|
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2014-03-27 17:46:00 +00:00
|
|
|
//
|
|
|
|
// Request a change in the power state of the emulated Apple
|
|
|
|
//
|
|
|
|
void SetPowerState(void)
|
2007-05-29 03:06:33 +00:00
|
|
|
{
|
2014-03-27 17:46:00 +00:00
|
|
|
powerStateChangeRequested = true;
|
2007-05-29 03:06:33 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
|
|
|
// Load a file into RAM/ROM image space
|
|
|
|
//
|
2013-09-09 02:18:23 +00:00
|
|
|
bool LoadImg(char * filename, uint8_t * ram, int size)
|
2007-05-29 03:06:33 +00:00
|
|
|
{
|
|
|
|
FILE * fp = fopen(filename, "rb");
|
|
|
|
|
|
|
|
if (fp == NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
fread(ram, 1, size, fp);
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
const uint8_t stateHeader[19] = "APPLE2SAVESTATE1.2";
|
2007-05-29 03:06:33 +00:00
|
|
|
static void SaveApple2State(const char * filename)
|
|
|
|
{
|
2014-04-02 18:00:00 +00:00
|
|
|
WriteLog("Main: Saving Apple2 state...\n");
|
|
|
|
FILE * file = fopen(filename, "wb");
|
|
|
|
|
|
|
|
if (!file)
|
|
|
|
{
|
|
|
|
WriteLog("Could not open file \"%s\" for writing!\n", filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write out header
|
|
|
|
fwrite(stateHeader, 1, 18, file);
|
|
|
|
|
|
|
|
// Write out CPU state
|
|
|
|
fwrite(&mainCPU, 1, sizeof(mainCPU), file);
|
|
|
|
|
|
|
|
// Write out main memory
|
|
|
|
fwrite(ram, 1, 0x10000, file);
|
|
|
|
fwrite(ram2, 1, 0x10000, file);
|
|
|
|
|
|
|
|
// Write out state variables
|
|
|
|
fputc((uint8_t)keyDown, file);
|
|
|
|
fputc((uint8_t)openAppleDown, file);
|
|
|
|
fputc((uint8_t)closedAppleDown, file);
|
|
|
|
fputc((uint8_t)store80Mode, file);
|
|
|
|
fputc((uint8_t)vbl, file);
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
fputc((uint8_t)intCXROM, file);
|
2014-04-02 18:00:00 +00:00
|
|
|
fputc((uint8_t)slotC3ROM, file);
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
fputc((uint8_t)intC8ROM, file);
|
2014-04-02 18:00:00 +00:00
|
|
|
fputc((uint8_t)ramrd, file);
|
|
|
|
fputc((uint8_t)ramwrt, file);
|
|
|
|
fputc((uint8_t)altzp, file);
|
|
|
|
fputc((uint8_t)ioudis, file);
|
|
|
|
fputc((uint8_t)dhires, file);
|
|
|
|
fputc((uint8_t)flash, file);
|
|
|
|
fputc((uint8_t)textMode, file);
|
|
|
|
fputc((uint8_t)mixedMode, file);
|
|
|
|
fputc((uint8_t)displayPage2, file);
|
|
|
|
fputc((uint8_t)hiRes, file);
|
|
|
|
fputc((uint8_t)alternateCharset, file);
|
|
|
|
fputc((uint8_t)col80Mode, file);
|
|
|
|
fputc(lcState, file);
|
|
|
|
|
|
|
|
// Write out floppy state
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
floppyDrive[0].SaveState(file);
|
|
|
|
|
|
|
|
// Write out Mockingboard state
|
|
|
|
MBSaveState(file);
|
2014-04-02 18:00:00 +00:00
|
|
|
fclose(file);
|
2007-05-29 03:06:33 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
static bool LoadApple2State(const char * filename)
|
|
|
|
{
|
2014-04-02 18:00:00 +00:00
|
|
|
WriteLog("Main: Loading Apple2 state...\n");
|
|
|
|
FILE * file = fopen(filename, "rb");
|
|
|
|
|
|
|
|
if (!file)
|
|
|
|
{
|
|
|
|
WriteLog("Could not open file \"%s\" for reading!\n", filename);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t buffer[18];
|
|
|
|
fread(buffer, 1, 18, file);
|
|
|
|
|
|
|
|
// Sanity check...
|
|
|
|
if (memcmp(buffer, stateHeader, 18) != 0)
|
|
|
|
{
|
|
|
|
fclose(file);
|
|
|
|
WriteLog("File \"%s\" is not a valid Apple2 save state file!\n", filename);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read CPU state
|
|
|
|
fread(&mainCPU, 1, sizeof(mainCPU), file);
|
|
|
|
|
|
|
|
// Read main memory
|
|
|
|
fread(ram, 1, 0x10000, file);
|
|
|
|
fread(ram2, 1, 0x10000, file);
|
|
|
|
|
|
|
|
// Read in state variables
|
|
|
|
keyDown = (bool)fgetc(file);
|
|
|
|
openAppleDown = (bool)fgetc(file);
|
|
|
|
closedAppleDown = (bool)fgetc(file);
|
|
|
|
store80Mode = (bool)fgetc(file);
|
|
|
|
vbl = (bool)fgetc(file);
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
intCXROM = (bool)fgetc(file);
|
2014-04-02 18:00:00 +00:00
|
|
|
slotC3ROM = (bool)fgetc(file);
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
intC8ROM = (bool)fgetc(file);
|
2014-04-02 18:00:00 +00:00
|
|
|
ramrd = (bool)fgetc(file);
|
|
|
|
ramwrt = (bool)fgetc(file);
|
|
|
|
altzp = (bool)fgetc(file);
|
|
|
|
ioudis = (bool)fgetc(file);
|
|
|
|
dhires = (bool)fgetc(file);
|
|
|
|
flash = (bool)fgetc(file);
|
|
|
|
textMode = (bool)fgetc(file);
|
|
|
|
mixedMode = (bool)fgetc(file);
|
|
|
|
displayPage2 = (bool)fgetc(file);
|
|
|
|
hiRes = (bool)fgetc(file);
|
|
|
|
alternateCharset = (bool)fgetc(file);
|
|
|
|
col80Mode = (bool)fgetc(file);
|
|
|
|
lcState = fgetc(file);
|
|
|
|
|
|
|
|
// Read in floppy state
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
floppyDrive[0].LoadState(file);
|
2014-04-02 18:00:00 +00:00
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// Read in Mockingboard state
|
|
|
|
MBLoadState(file);
|
2014-04-02 18:00:00 +00:00
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
// Make sure things are in a sane state before execution :-P
|
|
|
|
mainCPU.RdMem = AppleReadMem;
|
|
|
|
mainCPU.WrMem = AppleWriteMem;
|
2018-09-10 03:47:51 +00:00
|
|
|
mainCPU.Timer = AppleTimer;
|
2014-04-02 18:00:00 +00:00
|
|
|
ResetMMUPointers();
|
|
|
|
|
|
|
|
return true;
|
2007-05-29 03:06:33 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2014-03-27 17:46:00 +00:00
|
|
|
static void ResetApple2State(void)
|
|
|
|
{
|
|
|
|
keyDown = false;
|
|
|
|
openAppleDown = false;
|
|
|
|
closedAppleDown = false;
|
|
|
|
store80Mode = false;
|
|
|
|
vbl = false;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
intCXROM = false;
|
2014-03-27 17:46:00 +00:00
|
|
|
slotC3ROM = false;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
intC8ROM = false;
|
2014-03-27 17:46:00 +00:00
|
|
|
ramrd = false;
|
|
|
|
ramwrt = false;
|
|
|
|
altzp = false;
|
|
|
|
ioudis = true;
|
|
|
|
dhires = false;
|
|
|
|
lcState = 0x02;
|
2014-03-30 18:07:30 +00:00
|
|
|
ResetMMUPointers();
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
MBReset();
|
2014-03-30 18:07:30 +00:00
|
|
|
|
|
|
|
// Without this, you can wedge the system :-/
|
2014-03-27 17:46:00 +00:00
|
|
|
memset(ram, 0, 0x10000);
|
2017-06-22 03:57:57 +00:00
|
|
|
memset(ram2, 0, 0x10000);
|
2014-03-30 18:07:30 +00:00
|
|
|
mainCPU.cpuFlags |= V65C02_ASSERT_LINE_RESET;
|
2014-03-27 17:46:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
static double cyclesForSample = 0;
|
|
|
|
static void AppleTimer(uint16_t cycles)
|
|
|
|
{
|
|
|
|
// Handle PHI2 clocked stuff here...
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
MBRun(cycles);
|
|
|
|
floppyDrive[0].RunSequencer(cycles);
|
2018-09-10 03:47:51 +00:00
|
|
|
|
|
|
|
#if 1
|
|
|
|
// Handle sound
|
|
|
|
// 21.26009 cycles per sample @ 48000 (running @ 1,020,484.32 Hz)
|
|
|
|
// 16.688154500083 ms = 1 frame
|
|
|
|
cyclesForSample += (double)cycles;
|
|
|
|
|
|
|
|
if (cyclesForSample >= 21.26009)
|
|
|
|
{
|
|
|
|
#if 0
|
2018-09-17 02:45:27 +00:00
|
|
|
sampleClock = mainCPU.clock;
|
2018-09-10 03:47:51 +00:00
|
|
|
WriteLog(" cyclesForSample = %lf (%d samples, cycles=%d)\n", cyclesForSample, sampleClock - lastSampleClock, cycles);
|
|
|
|
sampleCount++;
|
|
|
|
lastSampleClock = sampleClock;
|
|
|
|
#endif
|
|
|
|
WriteSampleToBuffer();
|
|
|
|
cyclesForSample -= 21.26009;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-06 04:25:53 +00:00
|
|
|
#ifdef CPU_CLOCK_CHECKING
|
2013-09-09 02:18:23 +00:00
|
|
|
uint8_t counter = 0;
|
|
|
|
uint32_t totalCPU = 0;
|
|
|
|
uint64_t lastClock = 0;
|
2009-02-06 04:25:53 +00:00
|
|
|
#endif
|
2007-05-29 03:06:33 +00:00
|
|
|
//
|
|
|
|
// Main loop
|
|
|
|
//
|
|
|
|
int main(int /*argc*/, char * /*argv*/[])
|
|
|
|
{
|
|
|
|
InitLog("./apple2.log");
|
|
|
|
LoadSettings();
|
2017-06-05 03:28:52 +00:00
|
|
|
srand(time(NULL)); // Initialize RNG
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2017-06-22 03:57:57 +00:00
|
|
|
#if 0
|
|
|
|
// Make some timing/address tables
|
|
|
|
|
|
|
|
for(uint32_t line=0; line<262; line++)
|
|
|
|
{
|
|
|
|
WriteLog("LINE %03i: ", line);
|
|
|
|
|
|
|
|
for(uint32_t col=0; col<65; col++)
|
|
|
|
{
|
|
|
|
// Convert these to H/V counters
|
|
|
|
uint32_t hcount = col - 1;
|
|
|
|
|
|
|
|
// HC sees zero twice:
|
|
|
|
if (hcount == 0xFFFFFFFF)
|
|
|
|
hcount = 0;
|
|
|
|
|
|
|
|
uint32_t vcount = line + 0xFA;
|
|
|
|
|
|
|
|
// Now do the address calculations
|
|
|
|
uint32_t sum = 0xD + ((hcount & 0x38) >> 3)
|
|
|
|
+ (((vcount & 0xC0) >> 6) | ((vcount & 0xC0) >> 4));
|
|
|
|
uint32_t address = ((vcount & 0x38) << 4) | ((sum & 0x0F) << 3) | (hcount & 0x07);
|
|
|
|
|
|
|
|
// Add in particulars for the gfx mode we're in...
|
|
|
|
if (false)
|
|
|
|
// non hires
|
|
|
|
address |= (!(!store80Mode && displayPage2) ? 0x400 : 0)
|
|
|
|
| (!store80Mode && displayPage2 ? 0x800 : 0);
|
|
|
|
else
|
|
|
|
// hires
|
|
|
|
address |= (!(!store80Mode && displayPage2) ? 0x2000: 0)
|
|
|
|
| (!store80Mode && displayPage2 ? 0x4000 : 0)
|
|
|
|
| ((vcount & 0x07) << 10);
|
|
|
|
|
|
|
|
WriteLog("$%04X ", address);
|
|
|
|
}
|
|
|
|
|
|
|
|
WriteLog("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
// Zero out memory
|
|
|
|
memset(ram, 0, 0x10000);
|
|
|
|
memset(rom, 0, 0x10000);
|
2009-02-16 16:22:33 +00:00
|
|
|
memset(ram2, 0, 0x10000);
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2013-09-28 23:15:54 +00:00
|
|
|
// Set up MMU
|
|
|
|
SetupAddressMap();
|
2014-03-30 18:07:30 +00:00
|
|
|
ResetMMUPointers();
|
2013-09-28 23:15:54 +00:00
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// Install devices in slots
|
2019-02-07 13:46:21 +00:00
|
|
|
InstallFloppy(SLOT6);
|
|
|
|
InstallMockingboard(SLOT4);
|
2019-02-25 22:34:27 +00:00
|
|
|
InstallHardDrive(SLOT7);
|
2018-09-10 03:47:51 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
// Set up V65C02 execution context
|
|
|
|
memset(&mainCPU, 0, sizeof(V65C02REGS));
|
2013-09-28 23:15:54 +00:00
|
|
|
mainCPU.RdMem = AppleReadMem;
|
|
|
|
mainCPU.WrMem = AppleWriteMem;
|
2018-09-10 03:47:51 +00:00
|
|
|
mainCPU.Timer = AppleTimer;
|
2007-05-29 03:06:33 +00:00
|
|
|
mainCPU.cpuFlags |= V65C02_ASSERT_LINE_RESET;
|
|
|
|
|
2019-02-26 04:06:55 +00:00
|
|
|
#if 0
|
2013-09-19 00:03:09 +00:00
|
|
|
if (!LoadImg(settings.BIOSPath, rom + 0xC000, 0x4000))
|
2007-05-29 03:06:33 +00:00
|
|
|
{
|
|
|
|
WriteLog("Could not open file '%s'!\n", settings.BIOSPath);
|
|
|
|
return -1;
|
|
|
|
}
|
2019-02-26 04:06:55 +00:00
|
|
|
#else
|
|
|
|
memcpy(rom + 0xC000, apple2eEnhROM, 0x4000);
|
|
|
|
#endif
|
2007-05-29 03:06:33 +00:00
|
|
|
|
|
|
|
WriteLog("About to initialize video...\n");
|
2013-09-09 12:59:51 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
if (!InitVideo())
|
|
|
|
{
|
2017-06-05 03:28:52 +00:00
|
|
|
printf("Could not init screen: aborting!\n");
|
2007-05-29 03:06:33 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::Init(sdlRenderer);
|
2018-09-10 03:47:51 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
WriteLog("About to initialize audio...\n");
|
|
|
|
SoundInit();
|
2013-10-08 21:55:07 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
if (settings.autoStateSaving)
|
|
|
|
{
|
|
|
|
// Load last state from file...
|
|
|
|
if (!LoadApple2State(settings.autoStatePath))
|
|
|
|
WriteLog("Unable to use Apple2 state file \"%s\"!\n", settings.autoStatePath);
|
|
|
|
}
|
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
/*
|
|
|
|
So, how to run this then? Right now, we have two separate threads, one for the CPU and one for audio. The screen refresh is tied to the CPU thread.
|
|
|
|
|
|
|
|
To do this properly, however, we need to execute approximately 1,020,484.32 cycles per second, and we need to tie the AY/regular sound to this rate. Video should happen still approximately 60 times a second, even though the real thing has a frame rate of 59.92 Hz.
|
|
|
|
|
|
|
|
Right now, the speed of the CPU is tied to the host system's refresh rate (which seems to be somewhere around 59.9 Hz). Under this regime, the sound thread is starved much of the time, which means there's a timing mismatch somewhere between the sound thread and the CPU thread and the video (main) thread.
|
|
|
|
|
|
|
|
Other considerations: Even though we know the exact amount of cycles for one frame (17030 cycles to be exact), because the video frame rate is slightly under 60 (~59.92) the amount of time those cycles take can't be tied to the host system refresh rate, as they won't be the same (it will have about 8,000 or so more cycles in one second than it should have using 60 frames per second as the base frequency). However, we do know that the system clock is 14.318180 MHz, and we do know that 1 out of every 65 cycles will take 2 extra ticks of the system clock (cycles are normally 14 ticks of the system clock). So, by virtue of this, we know how long one frame is in seconds exactly (which would be (((65 * 14) + 2) * 262) / 14318180 = 16.688154500083 milliseconds).
|
|
|
|
|
|
|
|
So we need to decouple the CPU thread from the host video thread, and have the CPU frame run at its rate so that it will complete its running in its alloted time. We also need to have a little bit of cushion for the sound thread, so that its buffer doesn't starve. Assuming we get the timing correct, it will pull ahead and fall behind and all average out in the end.
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
running = true;
|
|
|
|
InitializeEventList();
|
|
|
|
// Set frame to fire at 1/60 s interval
|
|
|
|
SetCallbackTime(FrameCallback, 16666.66666667);
|
|
|
|
// Set up blinking at 1/4 s intervals
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// SetCallbackTime(BlinkTimer, 250000);
|
2007-05-29 03:06:33 +00:00
|
|
|
startTicks = SDL_GetTicks();
|
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
#ifdef THREADED_65C02
|
2017-06-05 03:28:52 +00:00
|
|
|
// Kick off the CPU...
|
2009-02-24 15:32:01 +00:00
|
|
|
cpuCond = SDL_CreateCond();
|
2013-09-11 15:00:36 +00:00
|
|
|
mainSem = SDL_CreateSemaphore(1);
|
2013-09-09 02:18:23 +00:00
|
|
|
cpuThread = SDL_CreateThread(CPUThreadFunc, NULL, NULL);
|
2009-02-24 15:32:01 +00:00
|
|
|
//Hmm... CPU does POST (+1), wait, then WAIT (-1)
|
|
|
|
// SDL_sem * mainMutex = SDL_CreateMutex();
|
2009-02-11 05:12:55 +00:00
|
|
|
#endif
|
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
WriteLog("Entering main loop...\n");
|
2013-10-08 21:55:07 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
while (running)
|
|
|
|
{
|
2018-09-10 03:47:51 +00:00
|
|
|
#ifdef CPU_CLOCK_CHECKING
|
2007-05-29 03:06:33 +00:00
|
|
|
double timeToNextEvent = GetTimeToNextEvent();
|
2018-09-10 03:47:51 +00:00
|
|
|
#endif
|
2009-02-11 05:12:55 +00:00
|
|
|
#ifndef THREADED_65C02
|
2007-05-29 03:06:33 +00:00
|
|
|
Execute65C02(&mainCPU, USEC_TO_M6502_CYCLES(timeToNextEvent));
|
2009-07-09 01:37:07 +00:00
|
|
|
|
2017-06-02 02:42:15 +00:00
|
|
|
#ifdef CPU_CLOCK_CHECKING
|
2009-02-06 04:25:53 +00:00
|
|
|
totalCPU += USEC_TO_M6502_CYCLES(timeToNextEvent);
|
2017-06-02 02:42:15 +00:00
|
|
|
#endif
|
2009-02-06 04:25:53 +00:00
|
|
|
#endif
|
2007-05-29 03:06:33 +00:00
|
|
|
HandleNextEvent();
|
|
|
|
}
|
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
#ifdef THREADED_65C02
|
2009-02-24 15:32:01 +00:00
|
|
|
WriteLog("Main: cpuFinished = true;\n");
|
2017-06-02 02:42:15 +00:00
|
|
|
cpuFinished = true;
|
|
|
|
|
2009-02-24 15:32:01 +00:00
|
|
|
WriteLog("Main: SDL_SemWait(mainSem);\n");
|
2014-04-01 13:47:16 +00:00
|
|
|
// Only do this if NOT in power off/emulation paused mode!
|
|
|
|
if (!pauseMode)
|
|
|
|
// Should lock until CPU thread is waiting...
|
|
|
|
SDL_SemWait(mainSem);
|
2009-02-24 15:32:01 +00:00
|
|
|
#endif
|
|
|
|
|
2017-06-02 02:42:15 +00:00
|
|
|
WriteLog("Main: SDL_CondSignal(cpuCond);\n");
|
|
|
|
SDL_CondSignal(cpuCond);//thread is probably asleep, so wake it up
|
2009-02-24 15:32:01 +00:00
|
|
|
WriteLog("Main: SDL_WaitThread(cpuThread, NULL);\n");
|
2014-04-01 13:47:16 +00:00
|
|
|
SDL_WaitThread(cpuThread, NULL);
|
2009-02-24 15:32:01 +00:00
|
|
|
WriteLog("Main: SDL_DestroyCond(cpuCond);\n");
|
2014-04-01 13:47:16 +00:00
|
|
|
SDL_DestroyCond(cpuCond);
|
|
|
|
SDL_DestroySemaphore(mainSem);
|
2009-02-11 05:12:55 +00:00
|
|
|
|
2017-06-02 02:42:15 +00:00
|
|
|
// Autosave state here, if requested...
|
2007-05-29 03:06:33 +00:00
|
|
|
if (settings.autoStateSaving)
|
|
|
|
SaveApple2State(settings.autoStatePath);
|
2014-04-01 13:47:16 +00:00
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
floppyDrive[0].SaveImage(0);
|
|
|
|
floppyDrive[0].SaveImage(1);
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
#include "dis65c02.h"
|
|
|
|
static char disbuf[80];
|
|
|
|
uint16_t pc=0x801;
|
|
|
|
while (pc < 0x9FF)
|
|
|
|
{
|
|
|
|
pc += Decode65C02(&mainCPU, disbuf, pc);
|
|
|
|
WriteLog("%s\n", disbuf);
|
|
|
|
}
|
|
|
|
#endif
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2019-04-17 03:29:58 +00:00
|
|
|
SaveSettings();
|
2007-05-29 03:06:33 +00:00
|
|
|
SoundDone();
|
|
|
|
VideoDone();
|
|
|
|
LogDone();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
//
|
|
|
|
// Apple //e scancodes. Tables are normal (0), +CTRL (1), +SHIFT (2),
|
|
|
|
// +CTRL+SHIFT (3). Order of keys is:
|
|
|
|
// Delete, left, tab, down, up, return, right, escape
|
|
|
|
// Space, single quote, comma, minus, period, slash
|
|
|
|
// Numbers 0-9
|
|
|
|
// Semicolon, equals, left bracket, backslash, right bracket, backquote
|
|
|
|
// Letters a-z (lowercase)
|
|
|
|
//
|
|
|
|
// N.B.: The Apple //e keyboard maps its shift characters like most modern US
|
2018-09-10 03:47:51 +00:00
|
|
|
// keyboards, so this table should suffice for the shifted keys just
|
|
|
|
// fine.
|
2017-06-05 03:28:52 +00:00
|
|
|
//
|
|
|
|
uint8_t apple2e_keycode[4][56] = {
|
|
|
|
{ // Normal
|
|
|
|
0x7F, 0x08, 0x09, 0x0A, 0x0B, 0x0D, 0x15, 0x1B,
|
|
|
|
0x20, 0x27, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
|
|
|
|
0x3B, 0x3D, 0x5B, 0x5C, 0x5D, 0x60,
|
|
|
|
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
|
|
|
|
0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
|
|
|
|
0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
|
|
|
|
},
|
|
|
|
{ // With CTRL held
|
|
|
|
0x7F, 0x08, 0x09, 0x0A, 0x0B, 0x0D, 0x15, 0x1B,
|
|
|
|
0x20, 0x27, 0x2C, 0x1F, 0x2E, 0x2F,
|
|
|
|
0x30, 0x31, 0x00, 0x33, 0x34, 0x35, 0x1E, 0x37, 0x38, 0x39,
|
|
|
|
0x3B, 0x3D, 0x1B, 0x1C, 0x1D, 0x60,
|
|
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
|
|
|
0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
|
|
|
|
0x15, 0x16, 0x17, 0x18, 0x19, 0x1A
|
|
|
|
},
|
|
|
|
{ // With Shift held
|
|
|
|
0x7F, 0x08, 0x09, 0x0A, 0x0B, 0x0D, 0x15, 0x1B,
|
|
|
|
0x20, 0x22, 0x3C, 0x5F, 0x3E, 0x3F,
|
|
|
|
0x29, 0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28,
|
|
|
|
0x3A, 0x2B, 0x7B, 0x7C, 0x7D, 0x7E,
|
|
|
|
0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
|
|
|
|
0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
|
|
|
|
0x55, 0x56, 0x57, 0x58, 0x59, 0x5A
|
|
|
|
},
|
|
|
|
{ // With CTRL+Shift held
|
|
|
|
0x7F, 0x08, 0x09, 0x0A, 0x0B, 0x0D, 0x15, 0x1B,
|
|
|
|
0x20, 0x22, 0x3C, 0x1F, 0x3E, 0x3F,
|
|
|
|
0x29, 0x21, 0x00, 0x23, 0x24, 0x25, 0x1E, 0x26, 0x2A, 0x28,
|
|
|
|
0x3A, 0x2B, 0x1B, 0x1C, 0x1D, 0x7E,
|
|
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
|
|
|
0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
|
|
|
|
0x15, 0x16, 0x17, 0x18, 0x19, 0x1A
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-09-11 22:33:54 +00:00
|
|
|
static uint32_t frameCount = 0;
|
2007-05-29 03:06:33 +00:00
|
|
|
static void FrameCallback(void)
|
|
|
|
{
|
|
|
|
SDL_Event event;
|
2017-06-05 03:28:52 +00:00
|
|
|
uint8_t keyIndex;
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
frameTimePtr = (frameTimePtr + 1) % 60;
|
|
|
|
frameTime[frameTimePtr] = startTicks;
|
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
while (SDL_PollEvent(&event))
|
|
|
|
{
|
|
|
|
switch (event.type)
|
|
|
|
{
|
2013-09-09 02:18:23 +00:00
|
|
|
case SDL_KEYDOWN:
|
2017-06-05 03:28:52 +00:00
|
|
|
// We do our own repeat handling thank you very much! :-)
|
|
|
|
if (event.key.repeat != 0)
|
|
|
|
break;
|
|
|
|
|
2019-04-17 03:29:58 +00:00
|
|
|
// This breaks IMEs and the like, but we'll do simple for now
|
|
|
|
if (GUI::KeyDown(event.key.keysym.sym))
|
|
|
|
break;
|
|
|
|
|
2017-06-02 02:42:15 +00:00
|
|
|
// Use CTRL+SHIFT+Q to exit, as well as the usual window decoration
|
|
|
|
// method
|
|
|
|
if ((event.key.keysym.mod & KMOD_CTRL)
|
|
|
|
&& (event.key.keysym.mod & KMOD_SHIFT)
|
|
|
|
&& (event.key.keysym.sym == SDLK_q))
|
|
|
|
{
|
2013-10-08 21:55:07 +00:00
|
|
|
running = false;
|
2017-06-02 02:42:15 +00:00
|
|
|
// We return here, because we don't want to pick up any
|
|
|
|
// spurious keypresses with our exit sequence.
|
|
|
|
return;
|
|
|
|
}
|
2013-10-08 21:55:07 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// CTRL+RESET key emulation (mapped to CTRL+HOME)
|
2017-06-02 02:42:15 +00:00
|
|
|
if ((event.key.keysym.mod & KMOD_CTRL)
|
2017-06-05 03:28:52 +00:00
|
|
|
&& (event.key.keysym.sym == SDLK_HOME))
|
2013-10-08 21:55:07 +00:00
|
|
|
{
|
2017-06-05 03:28:52 +00:00
|
|
|
//seems to leave the machine in an inconsistent state vis-a-vis the language card... [does it anymore?]
|
|
|
|
resetKeyDown = true;
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// Need to reset the MMU switches as well on RESET
|
|
|
|
intCXROM = false;
|
|
|
|
slotC3ROM = false;
|
|
|
|
intC8ROM = false;
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// There has GOT to be a better way off mapping SDLKs to our
|
|
|
|
// keyindex. But for now, this should suffice.
|
|
|
|
keyIndex = 0xFF;
|
2013-09-09 12:59:51 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
switch (event.key.keysym.sym)
|
2013-10-08 21:55:07 +00:00
|
|
|
{
|
2017-06-05 03:28:52 +00:00
|
|
|
case SDLK_BACKSPACE: keyIndex = 0; break;
|
|
|
|
case SDLK_LEFT: keyIndex = 1; break;
|
|
|
|
case SDLK_TAB: keyIndex = 2; break;
|
|
|
|
case SDLK_DOWN: keyIndex = 3; break;
|
|
|
|
case SDLK_UP: keyIndex = 4; break;
|
|
|
|
case SDLK_RETURN: keyIndex = 5; break;
|
|
|
|
case SDLK_RIGHT: keyIndex = 6; break;
|
|
|
|
case SDLK_ESCAPE: keyIndex = 7; break;
|
|
|
|
case SDLK_SPACE: keyIndex = 8; break;
|
|
|
|
case SDLK_QUOTE: keyIndex = 9; break;
|
|
|
|
case SDLK_COMMA: keyIndex = 10; break;
|
|
|
|
case SDLK_MINUS: keyIndex = 11; break;
|
|
|
|
case SDLK_PERIOD: keyIndex = 12; break;
|
|
|
|
case SDLK_SLASH: keyIndex = 13; break;
|
|
|
|
case SDLK_0: keyIndex = 14; break;
|
|
|
|
case SDLK_1: keyIndex = 15; break;
|
|
|
|
case SDLK_2: keyIndex = 16; break;
|
|
|
|
case SDLK_3: keyIndex = 17; break;
|
|
|
|
case SDLK_4: keyIndex = 18; break;
|
|
|
|
case SDLK_5: keyIndex = 19; break;
|
|
|
|
case SDLK_6: keyIndex = 20; break;
|
|
|
|
case SDLK_7: keyIndex = 21; break;
|
|
|
|
case SDLK_8: keyIndex = 22; break;
|
|
|
|
case SDLK_9: keyIndex = 23; break;
|
|
|
|
case SDLK_SEMICOLON: keyIndex = 24; break;
|
|
|
|
case SDLK_EQUALS: keyIndex = 25; break;
|
|
|
|
case SDLK_LEFTBRACKET: keyIndex = 26; break;
|
|
|
|
case SDLK_BACKSLASH: keyIndex = 27; break;
|
|
|
|
case SDLK_RIGHTBRACKET: keyIndex = 28; break;
|
|
|
|
case SDLK_BACKQUOTE: keyIndex = 29; break;
|
|
|
|
case SDLK_a: keyIndex = 30; break;
|
|
|
|
case SDLK_b: keyIndex = 31; break;
|
|
|
|
case SDLK_c: keyIndex = 32; break;
|
|
|
|
case SDLK_d: keyIndex = 33; break;
|
|
|
|
case SDLK_e: keyIndex = 34; break;
|
|
|
|
case SDLK_f: keyIndex = 35; break;
|
|
|
|
case SDLK_g: keyIndex = 36; break;
|
|
|
|
case SDLK_h: keyIndex = 37; break;
|
|
|
|
case SDLK_i: keyIndex = 38; break;
|
|
|
|
case SDLK_j: keyIndex = 39; break;
|
|
|
|
case SDLK_k: keyIndex = 40; break;
|
|
|
|
case SDLK_l: keyIndex = 41; break;
|
|
|
|
case SDLK_m: keyIndex = 42; break;
|
|
|
|
case SDLK_n: keyIndex = 43; break;
|
|
|
|
case SDLK_o: keyIndex = 44; break;
|
|
|
|
case SDLK_p: keyIndex = 45; break;
|
|
|
|
case SDLK_q: keyIndex = 46; break;
|
|
|
|
case SDLK_r: keyIndex = 47; break;
|
|
|
|
case SDLK_s: keyIndex = 48; break;
|
|
|
|
case SDLK_t: keyIndex = 49; break;
|
|
|
|
case SDLK_u: keyIndex = 50; break;
|
|
|
|
case SDLK_v: keyIndex = 51; break;
|
|
|
|
case SDLK_w: keyIndex = 52; break;
|
|
|
|
case SDLK_x: keyIndex = 53; break;
|
|
|
|
case SDLK_y: keyIndex = 54; break;
|
|
|
|
case SDLK_z: keyIndex = 55; break;
|
2013-10-08 21:55:07 +00:00
|
|
|
}
|
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// Stuff the key in if we have a valid one...
|
|
|
|
if (keyIndex != 0xFF)
|
2013-10-08 21:55:07 +00:00
|
|
|
{
|
2017-06-05 03:28:52 +00:00
|
|
|
// Handle Shift, CTRL, & Shift+CTRL combos
|
|
|
|
uint8_t table = 0;
|
|
|
|
|
|
|
|
if (event.key.keysym.mod & KMOD_CTRL)
|
|
|
|
table |= 1;
|
|
|
|
|
|
|
|
if (event.key.keysym.mod & KMOD_SHIFT)
|
|
|
|
table |= 2;
|
|
|
|
|
|
|
|
lastKeyPressed = apple2e_keycode[table][keyIndex];
|
2013-10-08 21:55:07 +00:00
|
|
|
keyDown = true;
|
|
|
|
|
2017-06-06 12:42:55 +00:00
|
|
|
// Handle Caps Lock
|
2018-09-10 03:47:51 +00:00
|
|
|
if ((SDL_GetModState() & KMOD_CAPS)
|
2017-06-06 12:42:55 +00:00
|
|
|
&& (lastKeyPressed >= 0x61) && (lastKeyPressed <= 0x7A))
|
|
|
|
lastKeyPressed -= 0x20;
|
|
|
|
|
|
|
|
// Handle key repeat if the key hasn't been held
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
keyDelay = 15;
|
2017-06-05 03:28:52 +00:00
|
|
|
keyDownCount++;
|
|
|
|
|
|
|
|
// Buffer the key held. Note that the last key is always
|
|
|
|
// stuffed into keysHeld[0].
|
|
|
|
if (keyDownCount >= 2)
|
|
|
|
{
|
|
|
|
keysHeld[1] = keysHeld[0];
|
|
|
|
keysHeldAppleCode[1] = keysHeldAppleCode[0];
|
|
|
|
|
|
|
|
if (keyDownCount > 2)
|
|
|
|
keyDownCount = 2;
|
|
|
|
}
|
2013-10-08 21:55:07 +00:00
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
keysHeld[0] = event.key.keysym.sym;
|
|
|
|
keysHeldAppleCode[0] = lastKeyPressed;
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-05-29 03:06:33 +00:00
|
|
|
|
2013-09-23 16:05:10 +00:00
|
|
|
if (event.key.keysym.sym == SDLK_PAUSE)
|
|
|
|
{
|
|
|
|
pauseMode = !pauseMode;
|
|
|
|
|
|
|
|
if (pauseMode)
|
|
|
|
{
|
|
|
|
SoundPause();
|
|
|
|
SpawnMessage("*** PAUSED ***");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SoundResume();
|
|
|
|
SpawnMessage("*** RESUME ***");
|
|
|
|
}
|
|
|
|
}
|
2017-06-05 03:28:52 +00:00
|
|
|
// Buttons 0 & 1
|
|
|
|
else if (event.key.keysym.sym == SDLK_LALT)
|
2013-09-10 03:22:49 +00:00
|
|
|
openAppleDown = true;
|
2017-06-05 03:28:52 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_RALT)
|
2013-09-10 03:22:49 +00:00
|
|
|
closedAppleDown = true;
|
2017-06-05 03:28:52 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F2)
|
2007-05-29 03:06:33 +00:00
|
|
|
TogglePalette();
|
2017-06-02 02:42:15 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F3)
|
2007-05-29 03:06:33 +00:00
|
|
|
CycleScreenTypes();
|
2018-09-10 03:47:51 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F4)
|
|
|
|
ToggleTickDisplay();
|
2014-03-27 17:46:00 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F5)
|
2009-02-06 04:25:53 +00:00
|
|
|
{
|
|
|
|
VolumeDown();
|
2009-02-24 15:32:01 +00:00
|
|
|
char volStr[19] = "[****************]";
|
2017-06-02 02:42:15 +00:00
|
|
|
|
2009-02-24 15:32:01 +00:00
|
|
|
for(int i=GetVolume(); i<16; i++)
|
|
|
|
volStr[1 + i] = '-';
|
2017-06-02 02:42:15 +00:00
|
|
|
|
2009-02-06 04:25:53 +00:00
|
|
|
SpawnMessage("Volume: %s", volStr);
|
|
|
|
}
|
|
|
|
else if (event.key.keysym.sym == SDLK_F6)
|
|
|
|
{
|
|
|
|
VolumeUp();
|
2009-02-24 15:32:01 +00:00
|
|
|
char volStr[19] = "[****************]";
|
2017-06-02 02:42:15 +00:00
|
|
|
|
2009-02-24 15:32:01 +00:00
|
|
|
for(int i=GetVolume(); i<16; i++)
|
|
|
|
volStr[1 + i] = '-';
|
2017-06-02 02:42:15 +00:00
|
|
|
|
2009-02-06 04:25:53 +00:00
|
|
|
SpawnMessage("Volume: %s", volStr);
|
|
|
|
}
|
2018-09-10 03:47:51 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F7)
|
|
|
|
{
|
|
|
|
// 4th root of 2 is ~1.18920711500272 (~1.5 dB)
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
// This attenuates by ~3 dB
|
|
|
|
VAY_3_8910::maxVolume /= 1.4142135f;
|
|
|
|
SpawnMessage("MB Volume: %d", (int)VAY_3_8910::maxVolume);
|
2018-09-10 03:47:51 +00:00
|
|
|
}
|
|
|
|
else if (event.key.keysym.sym == SDLK_F8)
|
|
|
|
{
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
VAY_3_8910::maxVolume *= 1.4142135f;
|
|
|
|
SpawnMessage("MB Volume: %d", (int)VAY_3_8910::maxVolume);
|
|
|
|
}
|
|
|
|
else if (event.key.keysym.sym == SDLK_F9)
|
|
|
|
{
|
|
|
|
floppyDrive[0].CreateBlankImage(1);
|
|
|
|
// SpawnMessage("Image cleared...");
|
|
|
|
}//*/
|
|
|
|
/*else if (event.key.keysym.sym == SDLK_F10)
|
|
|
|
{
|
|
|
|
floppyDrive[0].SwapImages();
|
|
|
|
// SpawnMessage("Image swapped...");
|
|
|
|
}//*/
|
|
|
|
// Toggle the disassembly process
|
|
|
|
else if (event.key.keysym.sym == SDLK_F11)
|
|
|
|
{
|
|
|
|
dumpDis = !dumpDis;
|
|
|
|
SpawnMessage("Trace: %s", (dumpDis ? "ON" : "off"));
|
2018-09-10 03:47:51 +00:00
|
|
|
}
|
2014-03-27 17:46:00 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_F12)
|
2013-09-09 02:18:23 +00:00
|
|
|
{
|
|
|
|
if (!fullscreenDebounce)
|
|
|
|
{
|
|
|
|
ToggleFullScreen();
|
|
|
|
fullscreenDebounce = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2013-09-09 02:18:23 +00:00
|
|
|
case SDL_KEYUP:
|
|
|
|
if (event.key.keysym.sym == SDLK_F12)
|
|
|
|
fullscreenDebounce = false;
|
2013-09-10 03:22:49 +00:00
|
|
|
// Paddle buttons 0 & 1
|
2017-06-05 03:28:52 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_LALT)
|
2013-09-10 03:22:49 +00:00
|
|
|
openAppleDown = false;
|
2017-06-05 03:28:52 +00:00
|
|
|
else if (event.key.keysym.sym == SDLK_RALT)
|
2013-09-10 03:22:49 +00:00
|
|
|
closedAppleDown = false;
|
2017-06-05 03:28:52 +00:00
|
|
|
else if ((event.key.keysym.mod & KMOD_CTRL)
|
|
|
|
&& (event.key.keysym.sym == SDLK_HOME))
|
|
|
|
resetKeyDown = false;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Handle key buffering 'key up' event (2 key rollover)
|
|
|
|
if ((keyDownCount == 1) && (event.key.keysym.sym == keysHeld[0]))
|
|
|
|
{
|
|
|
|
keyDownCount--;
|
2017-06-06 12:42:55 +00:00
|
|
|
keyDelay = 0; // Reset key delay
|
2017-06-05 03:28:52 +00:00
|
|
|
}
|
|
|
|
else if (keyDownCount == 2)
|
|
|
|
{
|
|
|
|
if (event.key.keysym.sym == keysHeld[0])
|
|
|
|
{
|
|
|
|
keyDownCount--;
|
|
|
|
keysHeld[0] = keysHeld[1];
|
|
|
|
keysHeldAppleCode[0] = keysHeldAppleCode[1];
|
|
|
|
}
|
|
|
|
else if (event.key.keysym.sym == keysHeld[1])
|
|
|
|
{
|
|
|
|
keyDownCount--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-09-10 03:22:49 +00:00
|
|
|
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2013-10-08 21:55:07 +00:00
|
|
|
case SDL_MOUSEBUTTONDOWN:
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::MouseDown(event.motion.x, event.motion.y, event.motion.state);
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2013-10-08 21:55:07 +00:00
|
|
|
case SDL_MOUSEBUTTONUP:
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::MouseUp(event.motion.x, event.motion.y, event.motion.state);
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2013-10-08 21:55:07 +00:00
|
|
|
case SDL_MOUSEMOTION:
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::MouseMove(event.motion.x, event.motion.y, event.motion.state);
|
2017-06-06 12:42:55 +00:00
|
|
|
|
|
|
|
// Handle mouse showing when the mouse is hidden...
|
|
|
|
if (hideMouseTimeout == -1)
|
|
|
|
SDL_ShowCursor(1);
|
|
|
|
|
|
|
|
hideMouseTimeout = 60;
|
2013-10-08 21:55:07 +00:00
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2013-10-08 21:55:07 +00:00
|
|
|
case SDL_WINDOWEVENT:
|
|
|
|
if (event.window.event == SDL_WINDOWEVENT_LEAVE)
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::MouseMove(0, 0, 0);
|
2013-10-08 21:55:07 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
break;
|
2017-06-05 03:28:52 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
case SDL_QUIT:
|
|
|
|
running = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-06 12:42:55 +00:00
|
|
|
// Hide the mouse if it's been 1s since the last time it was moved
|
|
|
|
// N.B.: Should disable mouse hiding if it's over the GUI...
|
2019-04-17 03:29:58 +00:00
|
|
|
if ((hideMouseTimeout > 0) && !(GUI::sidebarState == SBS_SHOWN || DiskSelector::showWindow == true || Config::showWindow == true))
|
2017-06-06 12:42:55 +00:00
|
|
|
hideMouseTimeout--;
|
|
|
|
else if (hideMouseTimeout == 0)
|
|
|
|
{
|
|
|
|
hideMouseTimeout--;
|
|
|
|
SDL_ShowCursor(0);
|
|
|
|
}
|
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// Stuff the Apple keyboard buffer, if any keys are pending
|
2017-06-06 12:42:55 +00:00
|
|
|
// N.B.: May have to simulate the key repeat delay too [yup, sure do]
|
2017-06-22 03:57:57 +00:00
|
|
|
// According to "Understanding the Apple IIe", the initial delay is
|
|
|
|
// between 32 & 48 jiffies and the repeat is every 4 jiffies.
|
2017-06-05 03:28:52 +00:00
|
|
|
if (keyDownCount > 0)
|
|
|
|
{
|
2017-06-06 12:42:55 +00:00
|
|
|
keyDelay--;
|
|
|
|
|
|
|
|
if (keyDelay == 0)
|
|
|
|
{
|
|
|
|
keyDelay = 3;
|
|
|
|
lastKeyPressed = keysHeldAppleCode[0];
|
|
|
|
keyDown = true;
|
|
|
|
}
|
2017-06-05 03:28:52 +00:00
|
|
|
}
|
|
|
|
|
2014-03-27 17:46:00 +00:00
|
|
|
// Handle power request from the GUI
|
|
|
|
if (powerStateChangeRequested)
|
|
|
|
{
|
|
|
|
if (GUI::powerOnState)
|
|
|
|
{
|
|
|
|
pauseMode = false;
|
2014-03-31 18:59:37 +00:00
|
|
|
// Unlock the CPU thread...
|
|
|
|
SDL_SemPost(mainSem);
|
2014-03-27 17:46:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pauseMode = true;
|
2014-03-31 18:59:37 +00:00
|
|
|
// Should lock until CPU thread is waiting...
|
|
|
|
SDL_SemWait(mainSem);
|
|
|
|
ResetApple2State();
|
2014-03-27 17:46:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
powerStateChangeRequested = false;
|
|
|
|
}
|
|
|
|
|
Misc. improvements, added WOZ file support to floppy emulation
- Refactored old MMU slot code to be more flexible
- Moved all Mockingboard related code to its own compilation unit
- Refactored old 6522 & AY-3-8910 code into v6522VIA & vAY8910 :-)
- Fixed BCD mode for ADC and SBC in v65C02
- Finally fixed text mode characters in both ALTCHARSET and regular
modes
- Added new floppy disk controller Logic State Sequencer emulation
- Fixed v65C02 to be cycle exact (as far as I can tell)
- Fixed a bunch of bugs in v65C02
- Dropped NIB support
- Added WOZ 1.0 file support
That last item is a bit of a big deal, as I had been thinking about
writing a new file format that would be bit-based--since the NIB nybble
format, while better than pretty much all the other formats out there,
fails hard in things like extra sync bits and half tracks. So, somewhat
serendipitously, I stumbled upon the Applesauce project and found out
that not only had other people been thinking in more or less the same
direction, they had created it and had made disk images to try!
So now, because of this, WOZ is the internal format used by the floppy
emulation (as opposed to NIB) which, along with the new disk Logic State
Sequencer emulator, makes it possible to format floppy disks correctly
for the first time. :-)
One ironic consequence of this is that NIB format can no longer be
properly supported. The irony comes from the fact that before there was
LSS emulation, NIB was the most accurate format you could get to
represent the low level format of a disk, but now, with proper LSS
emulation, it's the worst format for representing a floppy disk. And
the main reason for this is that NIB doesn't contain sync bits, and has
no mechanism to represent them--so when feeding them to the new LSS
emulation, they will fail horribly because without sync bits, the
bitstream represented by a NIB formatted disk can and will be
misinterpreted by the LSS. And since there is now a format that
properly represents the bitstream on a floppy disk (WOZ), there's
absolutely no reason to keep NIB around or support it anymore. While it
was a nice interim format to have around (when the emulation of the disk
was "imperfectly perfect"), it now no longer has a place in disk
preservation and/or emulation.
Another consequence of this new format is that Apple2 only supports
writing of WOZ images--it will no longer support writing of DSK and its
bretheren. However, since those formats are extremely limited in their
scope (they literally only represented the contents of the sectors on a
disk) we still support reading them; Apple2 will automagically upconvert
them and save them as WOZs (it will use the same filename but substitute
"woz" for the old extension). So if you're wondering why your DSKs are
unchanged when saving to them, you now know why. :-)
Big, big thanks to the Applesauce guys and everyone who contributed and
continues to contribute to that project; your efforts are very much
appreciated--you guys are awesome!
2019-01-24 02:33:05 +00:00
|
|
|
blinkTimer = (blinkTimer + 1) & 0x1F;
|
|
|
|
|
|
|
|
if (blinkTimer == 0)
|
|
|
|
flash = !flash;
|
|
|
|
|
2017-06-05 03:28:52 +00:00
|
|
|
// Render the Apple screen + GUI overlay
|
|
|
|
RenderAppleScreen(sdlRenderer);
|
2014-03-25 15:45:09 +00:00
|
|
|
GUI::Render(sdlRenderer);
|
2013-10-08 21:55:07 +00:00
|
|
|
SDL_RenderPresent(sdlRenderer);
|
2007-05-29 03:06:33 +00:00
|
|
|
SetCallbackTime(FrameCallback, 16666.66666667);
|
|
|
|
|
2009-02-06 04:25:53 +00:00
|
|
|
#ifdef CPU_CLOCK_CHECKING
|
2009-02-16 16:22:33 +00:00
|
|
|
//We know it's stopped, so we can get away with this...
|
2009-02-06 04:25:53 +00:00
|
|
|
counter++;
|
|
|
|
if (counter == 60)
|
|
|
|
{
|
2013-09-09 02:18:23 +00:00
|
|
|
uint64_t clock = GetCurrentV65C02Clock();
|
|
|
|
//totalCPU += (uint32_t)(clock - lastClock);
|
2009-02-24 15:32:01 +00:00
|
|
|
|
2013-09-09 02:18:23 +00:00
|
|
|
printf("Executed %u cycles...\n", (uint32_t)(clock - lastClock));
|
2009-02-24 15:32:01 +00:00
|
|
|
lastClock = clock;
|
|
|
|
// totalCPU = 0;
|
2009-02-06 04:25:53 +00:00
|
|
|
counter = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2013-09-11 22:33:54 +00:00
|
|
|
|
|
|
|
// This is the problem: If you set the interval to 16, it runs faster than
|
2018-09-10 03:47:51 +00:00
|
|
|
// 1/60s per frame. If you set it to 17, it runs slower. What we need is to
|
|
|
|
// have it do 16 for one frame, then 17 for two others. Then it should average
|
|
|
|
// out to 1/60s per frame every 3 frames. [And now it does!]
|
|
|
|
// Maybe we need a higher resolution timer, as the SDL_GetTicks() (in ms) seems
|
|
|
|
// to jitter all over the place...
|
2013-09-11 22:33:54 +00:00
|
|
|
frameCount = (frameCount + 1) % 3;
|
2018-09-10 03:47:51 +00:00
|
|
|
// uint32_t waitFrameTime = 17 - (frameCount == 0 ? 1 : 0);
|
|
|
|
// Get number of ticks burned in this frame, for displaying elsewhere
|
|
|
|
#if 0
|
|
|
|
frameTicks = SDL_GetTicks() - startTicks;
|
|
|
|
#else
|
|
|
|
frameTicks = ((SDL_GetPerformanceCounter() - startTicks) * 1000) / SDL_GetPerformanceFrequency();
|
|
|
|
#endif
|
2013-09-11 22:33:54 +00:00
|
|
|
|
2014-03-28 20:31:42 +00:00
|
|
|
// Wait for next frame...
|
2018-09-10 03:47:51 +00:00
|
|
|
// while (SDL_GetTicks() - startTicks < waitFrameTime)
|
|
|
|
// SDL_Delay(1);
|
2011-10-31 15:43:49 +00:00
|
|
|
|
2018-09-10 03:47:51 +00:00
|
|
|
#if 0
|
2007-05-29 03:06:33 +00:00
|
|
|
startTicks = SDL_GetTicks();
|
2018-09-10 03:47:51 +00:00
|
|
|
#else
|
|
|
|
startTicks = SDL_GetPerformanceCounter();
|
|
|
|
#endif
|
2013-09-19 00:03:09 +00:00
|
|
|
#if 0
|
2013-09-11 22:33:54 +00:00
|
|
|
uint64_t cpuCycles = GetCurrentV65C02Clock();
|
|
|
|
uint32_t cyclesBurned = (uint32_t)(cpuCycles - lastCPUCycles);
|
|
|
|
WriteLog("FrameCallback: used %i cycles\n", cyclesBurned);
|
2014-03-31 18:59:37 +00:00
|
|
|
lastCPUCycles = cpuCycles
|
2013-09-11 22:33:54 +00:00
|
|
|
#endif
|
|
|
|
|
2009-07-09 01:37:07 +00:00
|
|
|
//let's wait, then signal...
|
2017-05-18 04:17:17 +00:00
|
|
|
//works longer, but then still falls behind... [FIXED, see above]
|
2009-07-09 01:37:07 +00:00
|
|
|
#ifdef THREADED_65C02
|
2013-09-23 16:05:10 +00:00
|
|
|
if (!pauseMode)
|
|
|
|
SDL_CondSignal(cpuCond);//OK, let the CPU go another frame...
|
2009-07-09 01:37:07 +00:00
|
|
|
#endif
|
2007-05-29 03:06:33 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2007-05-29 03:06:33 +00:00
|
|
|
static void BlinkTimer(void)
|
|
|
|
{
|
2017-06-02 02:42:15 +00:00
|
|
|
// Set up blinking at 1/4 sec intervals
|
2007-05-29 03:06:33 +00:00
|
|
|
flash = !flash;
|
2017-06-02 02:42:15 +00:00
|
|
|
SetCallbackTime(BlinkTimer, 250000);
|
2007-05-29 03:06:33 +00:00
|
|
|
}
|
2009-02-11 05:12:55 +00:00
|
|
|
|
2013-09-11 15:00:36 +00:00
|
|
|
|
2009-02-11 05:12:55 +00:00
|
|
|
/*
|
|
|
|
Next problem is this: How to have events occur and synchronize with the rest
|
|
|
|
of the threads?
|
|
|
|
|
|
|
|
o Have the CPU thread manage the timer mechanism? (need to have a method of carrying
|
|
|
|
remainder CPU cycles over...)
|
|
|
|
|
2009-02-16 16:22:33 +00:00
|
|
|
One way would be to use a fractional accumulator, then subtract 1 every
|
|
|
|
time it overflows. Like so:
|
|
|
|
|
|
|
|
double overflow = 0;
|
2013-09-09 02:18:23 +00:00
|
|
|
uint32_t time = 20;
|
2009-02-16 16:22:33 +00:00
|
|
|
while (!done)
|
|
|
|
{
|
|
|
|
Execute6808(&soundCPU, time);
|
|
|
|
overflow += 0.289115646;
|
|
|
|
if (overflow > 1.0)
|
|
|
|
{
|
|
|
|
overflow -= 1.0;
|
|
|
|
time = 21;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
time = 20;
|
|
|
|
}
|
2009-02-11 05:12:55 +00:00
|
|
|
*/
|
2017-06-02 02:42:15 +00:00
|
|
|
|