ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Some minor improvements, self-documentation, etc. 

git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@3191 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba
This commit is contained in:
stephena 2015-08-09 18:07:04 +00:00
parent 237f0e5d35
commit 38dce5194e
9 changed files with 70 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/FrameBufferSDL2.cxx
View File

@ -86,7 +86,7 @@ void FrameBufferSDL2::queryHardware(vector<GUI::Size>& displays,
for(int i = 0; i < maxDisplays; ++i) for(int i = 0; i < maxDisplays; ++i)
{ {
SDL_GetDesktopDisplayMode(i, &display); SDL_GetDesktopDisplayMode(i, &display);
displays.push_back(GUI::Size(display.w, display.h)); displays.emplace_back(display.w, display.h);
} }
// For now, supported render types are hardcoded; eventually, SDL may // For now, supported render types are hardcoded; eventually, SDL may

54
src/common/SoundSDL2.cxx
View File

@ -25,6 +25,7 @@
#include <SDL.h> #include <SDL.h>
#include "TIASnd.hxx" #include "TIASnd.hxx"
#include "TIATables.hxx"
#include "FrameBuffer.hxx" #include "FrameBuffer.hxx"
#include "Settings.hxx" #include "Settings.hxx"
#include "System.hxx" #include "System.hxx"
@ -376,25 +377,19 @@ bool SoundSDL2::save(Serializer& out) const
{ {
out.putString(name()); out.putString(name());
uInt8 reg1 = 0, reg2 = 0, reg3 = 0, reg4 = 0, reg5 = 0, reg6 = 0;
// Only get the TIA sound registers if sound is enabled // Only get the TIA sound registers if sound is enabled
if(myIsInitializedFlag) if(myIsInitializedFlag)
{ {
reg1 = myTIASound.get(0x15); out.putByte(myTIASound.get(TIARegister::AUDC0));
reg2 = myTIASound.get(0x16); out.putByte(myTIASound.get(TIARegister::AUDC1));
reg3 = myTIASound.get(0x17); out.putByte(myTIASound.get(TIARegister::AUDF0));
reg4 = myTIASound.get(0x18); out.putByte(myTIASound.get(TIARegister::AUDF1));
reg5 = myTIASound.get(0x19); out.putByte(myTIASound.get(TIARegister::AUDV0));
reg6 = myTIASound.get(0x1a); out.putByte(myTIASound.get(TIARegister::AUDV1));
} }
else
out.putByte(reg1); for(int i = 0; i < 6; ++i)
out.putByte(reg2); out.putByte(0);
out.putByte(reg3);
out.putByte(reg4);
out.putByte(reg5);
out.putByte(reg6);
out.putInt(myLastRegisterSetCycle); out.putInt(myLastRegisterSetCycle);
} }
@ -415,29 +410,25 @@ bool SoundSDL2::load(Serializer& in)
if(in.getString() != name()) if(in.getString() != name())
return false; return false;
uInt8 reg1 = in.getByte(),
reg2 = in.getByte(),
reg3 = in.getByte(),
reg4 = in.getByte(),
reg5 = in.getByte(),
reg6 = in.getByte();
myLastRegisterSetCycle = (Int32) in.getInt();
// Only update the TIA sound registers if sound is enabled // Only update the TIA sound registers if sound is enabled
// Make sure to empty the queue of previous sound fragments // Make sure to empty the queue of previous sound fragments
if(myIsInitializedFlag) if(myIsInitializedFlag)
{ {
SDL_PauseAudio(1); SDL_PauseAudio(1);
myRegWriteQueue.clear(); myRegWriteQueue.clear();
myTIASound.set(0x15, reg1); myTIASound.set(TIARegister::AUDC0, in.getByte());
myTIASound.set(0x16, reg2); myTIASound.set(TIARegister::AUDC1, in.getByte());
myTIASound.set(0x17, reg3); myTIASound.set(TIARegister::AUDF0, in.getByte());
myTIASound.set(0x18, reg4); myTIASound.set(TIARegister::AUDF1, in.getByte());
myTIASound.set(0x19, reg5); myTIASound.set(TIARegister::AUDV0, in.getByte());
myTIASound.set(0x1a, reg6); myTIASound.set(TIARegister::AUDV1, in.getByte());
if(!myIsMuted) SDL_PauseAudio(0); if(!myIsMuted) SDL_PauseAudio(0);
} }
else
for(int i = 0; i < 6; ++i)
in.getByte();
myLastRegisterSetCycle = (Int32) in.getInt();
} }
catch(...) catch(...)
{ {
@ -450,13 +441,12 @@ bool SoundSDL2::load(Serializer& in)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SoundSDL2::RegWriteQueue::RegWriteQueue(uInt32 capacity) SoundSDL2::RegWriteQueue::RegWriteQueue(uInt32 capacity)
: myBuffer(nullptr), : myBuffer(make_ptr<RegWrite[]>(capacity)),
myCapacity(capacity), myCapacity(capacity),
mySize(0), mySize(0),
myHead(0), myHead(0),
myTail(0) myTail(0)
{ {
myBuffer = make_ptr<RegWrite[]>(myCapacity);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

9
src/emucore/AtariVox.cxx
View File

@ -115,12 +115,7 @@ void AtariVox::clockDataIn(bool value)
// If this is the first write this frame, or if it's been a long time // If this is the first write this frame, or if it's been a long time
// since the last write, start a new data byte. // since the last write, start a new data byte.
if(cycle < myLastDataWriteCycle) if((cycle < myLastDataWriteCycle) || (cycle > myLastDataWriteCycle + 1000))
{
myShiftRegister = 0;
myShiftCount = 0;
}
else if(cycle > myLastDataWriteCycle + 1000)
{ {
myShiftRegister = 0; myShiftRegister = 0;
myShiftCount = 0; myShiftCount = 0;
@ -128,7 +123,7 @@ void AtariVox::clockDataIn(bool value)
// If this is the first write this frame, or if it's been 62 cycles // If this is the first write this frame, or if it's been 62 cycles
// since the last write, shift this bit into the current byte. // since the last write, shift this bit into the current byte.
if(cycle < myLastDataWriteCycle || cycle >= myLastDataWriteCycle + 62) if((cycle < myLastDataWriteCycle) || (cycle >= myLastDataWriteCycle + 62))
{ {
myShiftRegister >>= 1; myShiftRegister >>= 1;
myShiftRegister |= (value << 15); myShiftRegister |= (value << 15);

36
src/emucore/Cart.cxx
View File

@ -525,7 +525,7 @@ string Cartridge::autodetectType(const uInt8* image, uInt32 size)
type = "4K"; // Most common bankswitching type type = "4K"; // Most common bankswitching type
} }
// Variable sized ROM formats are independent of image size and comes last // Variable sized ROM formats are independent of image size and come last
if(isProbablyDASH(image, size)) if(isProbablyDASH(image, size))
type = "DASH"; type = "DASH";
else if(isProbablyMDM(image, size)) else if(isProbablyMDM(image, size))
@ -724,14 +724,14 @@ bool Cartridge::isProbablyE0(const uInt8* image, uInt32 size)
// Thanks to "stella@casperkitty.com" for this advice // Thanks to "stella@casperkitty.com" for this advice
// These signatures are attributed to the MESS project // These signatures are attributed to the MESS project
uInt8 signature[8][3] = { uInt8 signature[8][3] = {
{ 0x8D, 0xE0, 0x1F }, // STA $1FE0 { 0x8D, 0xE0, 0x1F }, // STA $1FE0
{ 0x8D, 0xE0, 0x5F }, // STA $5FE0 { 0x8D, 0xE0, 0x5F }, // STA $5FE0
{ 0x8D, 0xE9, 0xFF }, // STA $FFE9 { 0x8D, 0xE9, 0xFF }, // STA $FFE9
{ 0x0C, 0xE0, 0x1F }, // NOP $1FE0 { 0x0C, 0xE0, 0x1F }, // NOP $1FE0
{ 0xAD, 0xE0, 0x1F }, // LDA $1FE0 { 0xAD, 0xE0, 0x1F }, // LDA $1FE0
{ 0xAD, 0xE9, 0xFF }, // LDA $FFE9 { 0xAD, 0xE9, 0xFF }, // LDA $FFE9
{ 0xAD, 0xED, 0xFF }, // LDA $FFED { 0xAD, 0xED, 0xFF }, // LDA $FFED
{ 0xAD, 0xF3, 0xBF } // LDA $BFF3 { 0xAD, 0xF3, 0xBF } // LDA $BFF3
}; };
for(uInt32 i = 0; i < 8; ++i) for(uInt32 i = 0; i < 8; ++i)
if(searchForBytes(image, size, signature[i], 3, 1)) if(searchForBytes(image, size, signature[i], 3, 1))
@ -750,13 +750,13 @@ bool Cartridge::isProbablyE7(const uInt8* image, uInt32 size)
// Thanks to "stella@casperkitty.com" for this advice // Thanks to "stella@casperkitty.com" for this advice
// These signatures are attributed to the MESS project // These signatures are attributed to the MESS project
uInt8 signature[7][3] = { uInt8 signature[7][3] = {
{ 0xAD, 0xE2, 0xFF }, // LDA $FFE2 { 0xAD, 0xE2, 0xFF }, // LDA $FFE2
{ 0xAD, 0xE5, 0xFF }, // LDA $FFE5 { 0xAD, 0xE5, 0xFF }, // LDA $FFE5
{ 0xAD, 0xE5, 0x1F }, // LDA $1FE5 { 0xAD, 0xE5, 0x1F }, // LDA $1FE5
{ 0xAD, 0xE7, 0x1F }, // LDA $1FE7 { 0xAD, 0xE7, 0x1F }, // LDA $1FE7
{ 0x0C, 0xE7, 0x1F }, // NOP $1FE7 { 0x0C, 0xE7, 0x1F }, // NOP $1FE7
{ 0x8D, 0xE7, 0xFF }, // STA $FFE7 { 0x8D, 0xE7, 0xFF }, // STA $FFE7
{ 0x8D, 0xE7, 0x1F } // STA $1FE7 { 0x8D, 0xE7, 0x1F } // STA $1FE7
}; };
for(uInt32 i = 0; i < 7; ++i) for(uInt32 i = 0; i < 7; ++i)
if(searchForBytes(image, size, signature[i], 3, 1)) if(searchForBytes(image, size, signature[i], 3, 1))
@ -818,7 +818,7 @@ bool Cartridge::isProbablyBF(const uInt8* image, uInt32 size, const char*& type)
{ {
// BF carts store strings 'BFBF' and 'BFSC' starting at address $FFF8 // BF carts store strings 'BFBF' and 'BFSC' starting at address $FFF8
// This signature is attributed to "RevEng" of AtariAge // This signature is attributed to "RevEng" of AtariAge
uInt8 bf[] = { 'B', 'F', 'B', 'F' }; uInt8 bf[] = { 'B', 'F', 'B', 'F' };
uInt8 bfsc[] = { 'B', 'F', 'S', 'C' }; uInt8 bfsc[] = { 'B', 'F', 'S', 'C' };
if(searchForBytes(image+size-8, 8, bf, 4, 1)) if(searchForBytes(image+size-8, 8, bf, 4, 1))
{ {
@ -840,7 +840,7 @@ bool Cartridge::isProbablyDF(const uInt8* image, uInt32 size, const char*& type)
// BF carts store strings 'DFDF' and 'DFSC' starting at address $FFF8 // BF carts store strings 'DFDF' and 'DFSC' starting at address $FFF8
// This signature is attributed to "RevEng" of AtariAge // This signature is attributed to "RevEng" of AtariAge
uInt8 df[] = { 'D', 'F', 'D', 'F' }; uInt8 df[] = { 'D', 'F', 'D', 'F' };
uInt8 dfsc[] = { 'D', 'F', 'S', 'C' }; uInt8 dfsc[] = { 'D', 'F', 'S', 'C' };
if(searchForBytes(image+size-8, 8, df, 4, 1)) if(searchForBytes(image+size-8, 8, df, 4, 1))
{ {

6
src/emucore/MT24LC256.cxx
View File

@ -104,12 +104,6 @@ MT24LC256::~MT24LC256()
} }
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool MT24LC256::readSDA() const
{
return jpee_mdat && jpee_sdat;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void MT24LC256::writeSDA(bool state) void MT24LC256::writeSDA(bool state)
{ {

2
src/emucore/MT24LC256.hxx
View File

@ -51,7 +51,7 @@ class MT24LC256
public: public:
/** Read boolean data from the SDA line */ /** Read boolean data from the SDA line */
bool readSDA() const; bool readSDA() const { return jpee_mdat && jpee_sdat; }
/** Write boolean data to the SDA and SCL lines */ /** Write boolean data to the SDA and SCL lines */
void writeSDA(bool state); void writeSDA(bool state);

33
src/emucore/System.cxx
View File

@ -101,39 +101,6 @@ void System::resetCycles()
myCycles = 0; myCycles = 0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void System::setPageAccess(uInt16 page, const PageAccess& access)
{
// Make sure the page is within range
assert(page < NUM_PAGES);
// Make sure the access methods make sense
assert(access.device != 0);
myPageAccessTable[page] = access;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const System::PageAccess& System::getPageAccess(uInt16 page) const
{
// Make sure the page is within range
assert(page < NUM_PAGES);
return myPageAccessTable[page];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
System::PageAccessType System::getPageAccessType(uInt16 addr) const
{
return myPageAccessTable[(addr & ADDRESS_MASK) >> PAGE_SHIFT].type;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void System::setDirtyPage(uInt16 addr)
{
myPageIsDirtyTable[(addr & ADDRESS_MASK) >> PAGE_SHIFT] = true;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool System::isPageDirty(uInt16 start_addr, uInt16 end_addr) const bool System::isPageDirty(uInt16 start_addr, uInt16 end_addr) const
{ {

16
src/emucore/System.hxx
View File

@ -313,7 +313,9 @@ class System : public Serializable
@param page The page accessing methods should be set for @param page The page accessing methods should be set for
@param access The accessing methods to be used by the page @param access The accessing methods to be used by the page
*/ */
void setPageAccess(uInt16 page, const PageAccess& access); void setPageAccess(uInt16 page, const PageAccess& access) {
myPageAccessTable[page] = access;
}
/** /**
Get the page accessing method for the specified page. Get the page accessing method for the specified page.
@ -321,7 +323,9 @@ class System : public Serializable
@param page The page to get accessing methods for @param page The page to get accessing methods for
@return The accessing methods used by the page @return The accessing methods used by the page
*/ */
const PageAccess& getPageAccess(uInt16 page) const; const PageAccess& getPageAccess(uInt16 page) const {
return myPageAccessTable[page];
}
/** /**
Get the page type for the given address. Get the page type for the given address.
@ -329,14 +333,18 @@ class System : public Serializable
@param addr The address contained in the page in questions @param addr The address contained in the page in questions
@return The type of page that contains the given address @return The type of page that contains the given address
*/ */
System::PageAccessType getPageAccessType(uInt16 addr) const; System::PageAccessType getPageAccessType(uInt16 addr) const {
return myPageAccessTable[(addr & ADDRESS_MASK) >> PAGE_SHIFT].type;
}
/** /**
Mark the page containing this address as being dirty. Mark the page containing this address as being dirty.
@param addr Determines the page that is dirty @param addr Determines the page that is dirty
*/ */
void setDirtyPage(uInt16 addr); void setDirtyPage(uInt16 addr) {
myPageIsDirtyTable[(addr & ADDRESS_MASK) >> PAGE_SHIFT] = true;
}
/** /**
Answer whether any pages in given range of addresses have been Answer whether any pages in given range of addresses have been

40
src/emucore/TIASnd.cxx
View File

@ -18,6 +18,7 @@
//============================================================================ //============================================================================
#include "System.hxx" #include "System.hxx"
#include "TIATables.hxx"
#include "TIASnd.hxx" #include "TIASnd.hxx"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -85,18 +86,18 @@ void TIASound::set(uInt16 address, uInt8 value)
int chan = ~address & 0x1; int chan = ~address & 0x1;
switch(address) switch(address)
{ {
case 0x15: // AUDC0 case TIARegister::AUDC0:
case 0x16: // AUDC1 case TIARegister::AUDC1:
myAUDC[chan] = value & 0x0f; myAUDC[chan] = value & 0x0f;
break; break;
case 0x17: // AUDF0 case TIARegister::AUDF0:
case 0x18: // AUDF1 case TIARegister::AUDF1:
myAUDF[chan] = value & 0x1f; myAUDF[chan] = value & 0x1f;
break; break;
case 0x19: // AUDV0 case TIARegister::AUDV0:
case 0x1a: // AUDV1 case TIARegister::AUDV1:
myAUDV[chan] = (value & 0x0f) << AUDV_SHIFT; myAUDV[chan] = (value & 0x0f) << AUDV_SHIFT;
break; break;
@ -142,26 +143,13 @@ uInt8 TIASound::get(uInt16 address) const
{ {
switch(address) switch(address)
{ {
case 0x15: // AUDC0 case TIARegister::AUDC0: return myAUDC[0];
return myAUDC[0]; case TIARegister::AUDC1: return myAUDC[1];
case TIARegister::AUDF0: return myAUDF[0];
case 0x16: // AUDC1 case TIARegister::AUDF1: return myAUDF[1];
return myAUDC[1]; case TIARegister::AUDV0: return myAUDV[0] >> AUDV_SHIFT;
case TIARegister::AUDV1: return myAUDV[1] >> AUDV_SHIFT;
case 0x17: // AUDF0 default: return 0;
return myAUDF[0];
case 0x18: // AUDF1
return myAUDF[1];
case 0x19: // AUDV0
return myAUDV[0] >> AUDV_SHIFT;
case 0x1a: // AUDV1
return myAUDV[1] >> AUDV_SHIFT;
default:
return 0;
} }
} }