TIA: update to latest Stella core
This commit is contained in:
tildearrow
parent
f2e519d71e
commit
fcefbb4909
|
|
@ -386,7 +386,8 @@ src/engine/platform/sound/c64_fp/WaveformCalculator.cpp
|
|||
src/engine/platform/sound/c64_fp/WaveformGenerator.cpp
|
||||
src/engine/platform/sound/c64_fp/resample/SincResampler.cpp
|
||||
|
||||
src/engine/platform/sound/tia/TIASnd.cpp
|
||||
src/engine/platform/sound/tia/AudioChannel.cpp
|
||||
src/engine/platform/sound/tia/Audio.cpp
|
||||
|
||||
src/engine/platform/sound/ymfm/ymfm_adpcm.cpp
|
||||
src/engine/platform/sound/ymfm/ymfm_opm.cpp
|
||||
|
|
|
|||
|
|
@ -0,0 +1,137 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2021 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//============================================================================
|
||||
|
||||
#define _USE_MATH_DEFINES
|
||||
#include "Audio.h"
|
||||
|
||||
#include <math.h>
|
||||
|
||||
namespace {
|
||||
constexpr double R_MAX = 30.;
|
||||
constexpr double R = 1.;
|
||||
|
||||
short mixingTableEntry(unsigned char v, unsigned char vMax)
|
||||
{
|
||||
return static_cast<short>(
|
||||
floor(0x7fff * double(v) / double(vMax) * (R_MAX + R * double(vMax)) / (R_MAX + R * double(v)))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
namespace TIA {
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
Audio::Audio()
|
||||
{
|
||||
for (unsigned char i = 0; i <= 0x1e; ++i) myMixingTableSum[i] = mixingTableEntry(i, 0x1e);
|
||||
for (unsigned char i = 0; i <= 0x0f; ++i) myMixingTableIndividual[i] = mixingTableEntry(i, 0x0f);
|
||||
|
||||
reset(false);
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void Audio::reset(bool st)
|
||||
{
|
||||
myCounter = 0;
|
||||
mySampleIndex = 0;
|
||||
stereo = st;
|
||||
|
||||
myCurrentSample[0]=0;
|
||||
myCurrentSample[1]=0;
|
||||
|
||||
myChannel0.reset();
|
||||
myChannel1.reset();
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void Audio::tick()
|
||||
{
|
||||
switch (myCounter) {
|
||||
case 9:
|
||||
case 81:
|
||||
myChannel0.phase0();
|
||||
myChannel1.phase0();
|
||||
|
||||
break;
|
||||
|
||||
case 37:
|
||||
case 149:
|
||||
phase1();
|
||||
break;
|
||||
}
|
||||
|
||||
if (++myCounter == 228) myCounter = 0;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void Audio::write(unsigned char addr, unsigned char val) {
|
||||
switch (addr&0x3f) {
|
||||
case 0x15:
|
||||
myChannel0.audc(val);
|
||||
break;
|
||||
case 0x16:
|
||||
myChannel1.audc(val);
|
||||
break;
|
||||
case 0x17:
|
||||
myChannel0.audf(val);
|
||||
break;
|
||||
case 0x18:
|
||||
myChannel1.audf(val);
|
||||
break;
|
||||
case 0x19:
|
||||
myChannel0.audv(val);
|
||||
break;
|
||||
case 0x1a:
|
||||
myChannel1.audv(val);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void Audio::phase1()
|
||||
{
|
||||
unsigned char sample0 = myChannel0.phase1();
|
||||
unsigned char sample1 = myChannel1.phase1();
|
||||
|
||||
addSample(sample0, sample1);
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void Audio::addSample(unsigned char sample0, unsigned char sample1)
|
||||
{
|
||||
if(stereo) {
|
||||
myCurrentSample[0] = myMixingTableIndividual[sample0];
|
||||
myCurrentSample[1] = myMixingTableIndividual[sample1];
|
||||
}
|
||||
else {
|
||||
myCurrentSample[0] = myMixingTableSum[sample0 + sample1];
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
AudioChannel& Audio::channel0()
|
||||
{
|
||||
return myChannel0;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
AudioChannel& Audio::channel1()
|
||||
{
|
||||
return myChannel1;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2021 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//============================================================================
|
||||
|
||||
#ifndef TIA_AUDIO_HXX
|
||||
#define TIA_AUDIO_HXX
|
||||
|
||||
#include "AudioChannel.h"
|
||||
#include <array>
|
||||
|
||||
namespace TIA {
|
||||
class Audio
|
||||
{
|
||||
public:
|
||||
Audio();
|
||||
|
||||
void reset(bool stereo);
|
||||
|
||||
void tick();
|
||||
|
||||
void write(unsigned char addr, unsigned char val);
|
||||
|
||||
AudioChannel& channel0();
|
||||
|
||||
AudioChannel& channel1();
|
||||
|
||||
short myCurrentSample[2];
|
||||
|
||||
private:
|
||||
void phase1();
|
||||
void addSample(unsigned char sample0, unsigned char sample1);
|
||||
|
||||
private:
|
||||
unsigned char myCounter{0};
|
||||
|
||||
AudioChannel myChannel0;
|
||||
AudioChannel myChannel1;
|
||||
|
||||
bool stereo;
|
||||
|
||||
std::array<short, 0x1e + 1> myMixingTableSum;
|
||||
std::array<short, 0x0f + 1> myMixingTableIndividual;
|
||||
|
||||
unsigned int mySampleIndex{0};
|
||||
#ifdef GUI_SUPPORT
|
||||
bool myRewindMode{false};
|
||||
mutable ByteArray mySamples;
|
||||
#endif
|
||||
|
||||
private:
|
||||
Audio(const Audio&) = delete;
|
||||
Audio(Audio&&) = delete;
|
||||
Audio& operator=(const Audio&) = delete;
|
||||
Audio& operator=(Audio&&) = delete;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // TIA_AUDIO_HXX
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2021 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//============================================================================
|
||||
|
||||
#include "AudioChannel.h"
|
||||
|
||||
namespace TIA {
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void AudioChannel::reset()
|
||||
{
|
||||
myAudc = myAudv = myAudf = 0;
|
||||
myClockEnable = myNoiseFeedback = myNoiseCounterBit4 = myPulseCounterHold = false;
|
||||
myDivCounter = myPulseCounter = myNoiseCounter = 0;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void AudioChannel::phase0()
|
||||
{
|
||||
if (myClockEnable) {
|
||||
myNoiseCounterBit4 = myNoiseCounter & 0x01;
|
||||
|
||||
switch (myAudc & 0x03) {
|
||||
case 0x00:
|
||||
case 0x01:
|
||||
myPulseCounterHold = false;
|
||||
break;
|
||||
|
||||
case 0x02:
|
||||
myPulseCounterHold = (myNoiseCounter & 0x1e) != 0x02;
|
||||
break;
|
||||
|
||||
case 0x03:
|
||||
myPulseCounterHold = !myNoiseCounterBit4;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (myAudc & 0x03) {
|
||||
case 0x00:
|
||||
myNoiseFeedback =
|
||||
((myPulseCounter ^ myNoiseCounter) & 0x01) ||
|
||||
!(myNoiseCounter || (myPulseCounter != 0x0a)) ||
|
||||
!(myAudc & 0x0c);
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
myNoiseFeedback =
|
||||
(((myNoiseCounter & 0x04) ? 1 : 0) ^ (myNoiseCounter & 0x01)) ||
|
||||
myNoiseCounter == 0;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
myClockEnable = myDivCounter == myAudf;
|
||||
|
||||
if (myDivCounter == myAudf || myDivCounter == 0x1f) {
|
||||
myDivCounter = 0;
|
||||
} else {
|
||||
++myDivCounter;
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
unsigned char AudioChannel::phase1()
|
||||
{
|
||||
if (myClockEnable) {
|
||||
bool pulseFeedback = false;
|
||||
switch (myAudc >> 2) {
|
||||
case 0x00:
|
||||
pulseFeedback =
|
||||
(((myPulseCounter & 0x02) ? 1 : 0) ^ (myPulseCounter & 0x01)) &&
|
||||
(myPulseCounter != 0x0a) &&
|
||||
(myAudc & 0x03);
|
||||
|
||||
break;
|
||||
|
||||
case 0x01:
|
||||
pulseFeedback = !(myPulseCounter & 0x08);
|
||||
break;
|
||||
|
||||
case 0x02:
|
||||
pulseFeedback = !myNoiseCounterBit4;
|
||||
break;
|
||||
|
||||
case 0x03:
|
||||
pulseFeedback = !((myPulseCounter & 0x02) || !(myPulseCounter & 0x0e));
|
||||
break;
|
||||
}
|
||||
|
||||
myNoiseCounter >>= 1;
|
||||
if (myNoiseFeedback) {
|
||||
myNoiseCounter |= 0x10;
|
||||
}
|
||||
|
||||
if (!myPulseCounterHold) {
|
||||
myPulseCounter = ~(myPulseCounter >> 1) & 0x07;
|
||||
|
||||
if (pulseFeedback) {
|
||||
myPulseCounter |= 0x08;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (myPulseCounter & 0x01) * myAudv;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void AudioChannel::audc(unsigned char value)
|
||||
{
|
||||
myAudc = value & 0x0f;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void AudioChannel::audv(unsigned char value)
|
||||
{
|
||||
myAudv = value & 0x0f;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void AudioChannel::audf(unsigned char value)
|
||||
{
|
||||
myAudf = value & 0x1f;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2021 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//============================================================================
|
||||
|
||||
#ifndef TIA_AUDIO_CHANNEL_HXX
|
||||
#define TIA_AUDIO_CHANNEL_HXX
|
||||
|
||||
namespace TIA {
|
||||
class AudioChannel
|
||||
{
|
||||
public:
|
||||
AudioChannel() = default;
|
||||
|
||||
void reset();
|
||||
|
||||
void phase0();
|
||||
|
||||
unsigned char phase1();
|
||||
|
||||
void audc(unsigned char value);
|
||||
|
||||
void audf(unsigned char value);
|
||||
|
||||
void audv(unsigned char value);
|
||||
|
||||
private:
|
||||
unsigned char myAudc{0};
|
||||
unsigned char myAudv{0};
|
||||
unsigned char myAudf{0};
|
||||
|
||||
bool myClockEnable{false};
|
||||
bool myNoiseFeedback{false};
|
||||
bool myNoiseCounterBit4{false};
|
||||
bool myPulseCounterHold{false};
|
||||
|
||||
unsigned char myDivCounter{0};
|
||||
unsigned char myPulseCounter{0};
|
||||
unsigned char myNoiseCounter{0};
|
||||
|
||||
private:
|
||||
AudioChannel(const AudioChannel&) = delete;
|
||||
AudioChannel(AudioChannel&&) = delete;
|
||||
AudioChannel& operator=(const AudioChannel&) = delete;
|
||||
AudioChannel& operator=(AudioChannel&&) = delete;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // TIA_AUDIO_CHANNEL_HXX
|
||||
|
|
@ -1,377 +0,0 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2016 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//
|
||||
// $Id: TIASnd.cxx 3239 2015-12-29 19:22:46Z stephena $
|
||||
//============================================================================
|
||||
|
||||
#include "TIATables.h"
|
||||
#include "TIASnd.h"
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
TIASound::TIASound(int outputFrequency)
|
||||
: myChannelMode(Hardware2Stereo),
|
||||
myOutputFrequency(outputFrequency),
|
||||
myVolumePercentage(100)
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::reset()
|
||||
{
|
||||
// Fill the polynomials
|
||||
polyInit(Bit4, 4, 4, 3);
|
||||
polyInit(Bit5, 5, 5, 3);
|
||||
polyInit(Bit9, 9, 9, 5);
|
||||
|
||||
// Initialize instance variables
|
||||
for(int chan = 0; chan <= 1; ++chan)
|
||||
{
|
||||
myVolume[chan] = 0;
|
||||
myDivNCnt[chan] = 0;
|
||||
myDivNMax[chan] = 0;
|
||||
myDiv3Cnt[chan] = 3;
|
||||
myAUDC[chan] = 0;
|
||||
myAUDF[chan] = 0;
|
||||
myAUDV[chan] = 0;
|
||||
myP4[chan] = 0;
|
||||
myP5[chan] = 0;
|
||||
myP9[chan] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::outputFrequency(int freq)
|
||||
{
|
||||
myOutputFrequency = freq;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
std::string TIASound::channels(unsigned int hardware, bool stereo)
|
||||
{
|
||||
if(hardware == 1)
|
||||
myChannelMode = Hardware1;
|
||||
else
|
||||
myChannelMode = stereo ? Hardware2Stereo : Hardware2Mono;
|
||||
|
||||
switch(myChannelMode)
|
||||
{
|
||||
case Hardware1: return "Hardware1";
|
||||
case Hardware2Mono: return "Hardware2Mono";
|
||||
case Hardware2Stereo: return "Hardware2Stereo";
|
||||
default: return "";
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::set(unsigned short address, unsigned char value)
|
||||
{
|
||||
int chan = ~address & 0x1;
|
||||
switch(address)
|
||||
{
|
||||
case TIARegister::AUDC0:
|
||||
case TIARegister::AUDC1:
|
||||
myAUDC[chan] = value & 0x0f;
|
||||
break;
|
||||
|
||||
case TIARegister::AUDF0:
|
||||
case TIARegister::AUDF1:
|
||||
myAUDF[chan] = value & 0x1f;
|
||||
break;
|
||||
|
||||
case TIARegister::AUDV0:
|
||||
case TIARegister::AUDV1:
|
||||
myAUDV[chan] = (value & 0x0f) << AUDV_SHIFT;
|
||||
break;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned short newVal = 0;
|
||||
|
||||
// An AUDC value of 0 is a special case
|
||||
if (myAUDC[chan] == SET_TO_1 || myAUDC[chan] == POLY5_POLY5)
|
||||
{
|
||||
// Indicate the clock is zero so no processing will occur,
|
||||
// and set the output to the selected volume
|
||||
newVal = 0;
|
||||
myVolume[chan] = (myAUDV[chan] * myVolumePercentage) / 100;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Otherwise calculate the 'divide by N' value
|
||||
newVal = myAUDF[chan] + 1;
|
||||
|
||||
// If bits 2 & 3 are set, then multiply the 'div by n' count by 3
|
||||
if((myAUDC[chan] & DIV3_MASK) == DIV3_MASK && myAUDC[chan] != POLY5_DIV3)
|
||||
newVal *= 3;
|
||||
}
|
||||
|
||||
// Only reset those channels that have changed
|
||||
if(newVal != myDivNMax[chan])
|
||||
{
|
||||
// Reset the divide by n counters
|
||||
myDivNMax[chan] = newVal;
|
||||
|
||||
// If the channel is now volume only or was volume only,
|
||||
// reset the counter (otherwise let it complete the previous)
|
||||
if ((myDivNCnt[chan] == 0) || (newVal == 0))
|
||||
myDivNCnt[chan] = newVal;
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
unsigned char TIASound::get(unsigned short address) const
|
||||
{
|
||||
switch(address)
|
||||
{
|
||||
case TIARegister::AUDC0: return myAUDC[0];
|
||||
case TIARegister::AUDC1: return myAUDC[1];
|
||||
case TIARegister::AUDF0: return myAUDF[0];
|
||||
case TIARegister::AUDF1: return myAUDF[1];
|
||||
case TIARegister::AUDV0: return myAUDV[0] >> AUDV_SHIFT;
|
||||
case TIARegister::AUDV1: return myAUDV[1] >> AUDV_SHIFT;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::volume(unsigned int percent)
|
||||
{
|
||||
if(percent <= 100)
|
||||
myVolumePercentage = percent;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::process(short* buffer, unsigned int samples, DivDispatchOscBuffer** oscBuf)
|
||||
{
|
||||
// Make temporary local copy
|
||||
unsigned char audc0 = myAUDC[0], audc1 = myAUDC[1];
|
||||
unsigned char p5_0 = myP5[0], p5_1 = myP5[1];
|
||||
unsigned char div_n_cnt0 = myDivNCnt[0], div_n_cnt1 = myDivNCnt[1];
|
||||
short v0 = myVolume[0], v1 = myVolume[1];
|
||||
|
||||
// Take external volume into account
|
||||
short audv0 = (myAUDV[0] * myVolumePercentage) / 100,
|
||||
audv1 = (myAUDV[1] * myVolumePercentage) / 100;
|
||||
|
||||
// Loop until the sample buffer is full
|
||||
while(samples > 0)
|
||||
{
|
||||
// Process channel 0
|
||||
if (div_n_cnt0 > 1)
|
||||
{
|
||||
div_n_cnt0--;
|
||||
}
|
||||
else if (div_n_cnt0 == 1)
|
||||
{
|
||||
int prev_bit5 = Bit5[p5_0];
|
||||
div_n_cnt0 = myDivNMax[0];
|
||||
|
||||
// The P5 counter has multiple uses, so we increment it here
|
||||
p5_0++;
|
||||
if (p5_0 == POLY5_SIZE)
|
||||
p5_0 = 0;
|
||||
|
||||
// Check clock modifier for clock tick
|
||||
if ((audc0 & 0x02) == 0 ||
|
||||
((audc0 & 0x01) == 0 && Div31[p5_0]) ||
|
||||
((audc0 & 0x01) == 1 && Bit5[p5_0]) ||
|
||||
((audc0 & 0x0f) == POLY5_DIV3 && Bit5[p5_0] != prev_bit5))
|
||||
{
|
||||
if (audc0 & 0x04) // Pure modified clock selected
|
||||
{
|
||||
if ((audc0 & 0x0f) == POLY5_DIV3) // POLY5 -> DIV3 mode
|
||||
{
|
||||
if ( Bit5[p5_0] != prev_bit5 )
|
||||
{
|
||||
myDiv3Cnt[0]--;
|
||||
if ( !myDiv3Cnt[0] )
|
||||
{
|
||||
myDiv3Cnt[0] = 3;
|
||||
v0 = v0 ? 0 : audv0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// If the output was set turn it off, else turn it on
|
||||
v0 = v0 ? 0 : audv0;
|
||||
}
|
||||
}
|
||||
else if (audc0 & 0x08) // Check for p5/p9
|
||||
{
|
||||
if (audc0 == POLY9) // Check for poly9
|
||||
{
|
||||
// Increase the poly9 counter
|
||||
myP9[0]++;
|
||||
if (myP9[0] == POLY9_SIZE)
|
||||
myP9[0] = 0;
|
||||
|
||||
v0 = Bit9[myP9[0]] ? audv0 : 0;
|
||||
}
|
||||
else if ( audc0 & 0x02 )
|
||||
{
|
||||
v0 = (v0 || audc0 & 0x01) ? 0 : audv0;
|
||||
}
|
||||
else // Must be poly5
|
||||
{
|
||||
v0 = Bit5[p5_0] ? audv0 : 0;
|
||||
}
|
||||
}
|
||||
else // Poly4 is the only remaining option
|
||||
{
|
||||
// Increase the poly4 counter
|
||||
myP4[0]++;
|
||||
if (myP4[0] == POLY4_SIZE)
|
||||
myP4[0] = 0;
|
||||
|
||||
v0 = Bit4[myP4[0]] ? audv0 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Process channel 1
|
||||
if (div_n_cnt1 > 1)
|
||||
{
|
||||
div_n_cnt1--;
|
||||
}
|
||||
else if (div_n_cnt1 == 1)
|
||||
{
|
||||
int prev_bit5 = Bit5[p5_1];
|
||||
|
||||
div_n_cnt1 = myDivNMax[1];
|
||||
|
||||
// The P5 counter has multiple uses, so we increment it here
|
||||
p5_1++;
|
||||
if (p5_1 == POLY5_SIZE)
|
||||
p5_1 = 0;
|
||||
|
||||
// Check clock modifier for clock tick
|
||||
if ((audc1 & 0x02) == 0 ||
|
||||
((audc1 & 0x01) == 0 && Div31[p5_1]) ||
|
||||
((audc1 & 0x01) == 1 && Bit5[p5_1]) ||
|
||||
((audc1 & 0x0f) == POLY5_DIV3 && Bit5[p5_1] != prev_bit5))
|
||||
{
|
||||
if (audc1 & 0x04) // Pure modified clock selected
|
||||
{
|
||||
if ((audc1 & 0x0f) == POLY5_DIV3) // POLY5 -> DIV3 mode
|
||||
{
|
||||
if ( Bit5[p5_1] != prev_bit5 )
|
||||
{
|
||||
myDiv3Cnt[1]--;
|
||||
if ( ! myDiv3Cnt[1] )
|
||||
{
|
||||
myDiv3Cnt[1] = 3;
|
||||
v1 = v1 ? 0 : audv1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// If the output was set turn it off, else turn it on
|
||||
v1 = v1 ? 0 : audv1;
|
||||
}
|
||||
}
|
||||
else if (audc1 & 0x08) // Check for p5/p9
|
||||
{
|
||||
if (audc1 == POLY9) // Check for poly9
|
||||
{
|
||||
// Increase the poly9 counter
|
||||
myP9[1]++;
|
||||
if (myP9[1] == POLY9_SIZE)
|
||||
myP9[1] = 0;
|
||||
|
||||
v1 = Bit9[myP9[1]] ? audv1 : 0;
|
||||
}
|
||||
else if ( audc1 & 0x02 )
|
||||
{
|
||||
v1 = (v1 || audc1 & 0x01) ? 0 : audv1;
|
||||
}
|
||||
else // Must be poly5
|
||||
{
|
||||
v1 = Bit5[p5_1] ? audv1 : 0;
|
||||
}
|
||||
}
|
||||
else // Poly4 is the only remaining option
|
||||
{
|
||||
// Increase the poly4 counter
|
||||
myP4[1]++;
|
||||
if (myP4[1] == POLY4_SIZE)
|
||||
myP4[1] = 0;
|
||||
|
||||
v1 = Bit4[myP4[1]] ? audv1 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
short byte = v0 + v1;
|
||||
switch(myChannelMode)
|
||||
{
|
||||
case Hardware2Mono: // mono sampling with 2 hardware channels
|
||||
*(buffer++) = byte;
|
||||
*(buffer++) = byte;
|
||||
samples--;
|
||||
break;
|
||||
|
||||
case Hardware2Stereo: // stereo sampling with 2 hardware channels
|
||||
*(buffer++) = v0;
|
||||
*(buffer++) = v1;
|
||||
samples--;
|
||||
break;
|
||||
|
||||
case Hardware1: // mono/stereo sampling with only 1 hardware channel
|
||||
*(buffer++) = (v0 + v1) >> 1;
|
||||
samples--;
|
||||
break;
|
||||
}
|
||||
|
||||
if (oscBuf!=NULL) {
|
||||
oscBuf[0]->data[oscBuf[0]->needle++]=v0;
|
||||
oscBuf[1]->data[oscBuf[1]->needle++]=v1;
|
||||
}
|
||||
}
|
||||
|
||||
// Save for next round
|
||||
myP5[0] = p5_0;
|
||||
myP5[1] = p5_1;
|
||||
myVolume[0] = v0;
|
||||
myVolume[1] = v1;
|
||||
myDivNCnt[0] = div_n_cnt0;
|
||||
myDivNCnt[1] = div_n_cnt1;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void TIASound::polyInit(unsigned char* poly, int size, int f0, int f1)
|
||||
{
|
||||
int mask = (1 << size) - 1, x = mask;
|
||||
|
||||
for(int i = 0; i < mask; i++)
|
||||
{
|
||||
int bit0 = ( ( size - f0 ) ? ( x >> ( size - f0 ) ) : x ) & 0x01;
|
||||
int bit1 = ( ( size - f1 ) ? ( x >> ( size - f1 ) ) : x ) & 0x01;
|
||||
poly[i] = x & 1;
|
||||
// calculate next bit
|
||||
x = ( x >> 1 ) | ( ( bit0 ^ bit1 ) << ( size - 1) );
|
||||
}
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
const unsigned char TIASound::Div31[POLY5_SIZE] = {
|
||||
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
|
@ -1,186 +0,0 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2016 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//
|
||||
// $Id: TIASnd.hxx 3239 2015-12-29 19:22:46Z stephena $
|
||||
//============================================================================
|
||||
|
||||
#ifndef TIASOUND_HXX
|
||||
#define TIASOUND_HXX
|
||||
|
||||
#include <string>
|
||||
#include "../../../dispatch.h"
|
||||
|
||||
/**
|
||||
This class implements a fairly accurate emulation of the TIA sound
|
||||
hardware. This class uses code/ideas from z26 and MESS.
|
||||
|
||||
Currently, the sound generation routines work at 31400Hz only.
|
||||
Resampling can be done by passing in a different output frequency.
|
||||
|
||||
@author Bradford W. Mott, Stephen Anthony, z26 and MESS teams
|
||||
@version $Id: TIASnd.hxx 3239 2015-12-29 19:22:46Z stephena $
|
||||
*/
|
||||
class TIASound
|
||||
{
|
||||
public:
|
||||
/**
|
||||
Create a new TIA Sound object using the specified output frequency
|
||||
*/
|
||||
TIASound(int outputFrequency = 31400);
|
||||
|
||||
public:
|
||||
/**
|
||||
Reset the sound emulation to its power-on state
|
||||
*/
|
||||
void reset();
|
||||
|
||||
/**
|
||||
Set the frequency output samples should be generated at
|
||||
*/
|
||||
void outputFrequency(int freq);
|
||||
|
||||
/**
|
||||
Selects the number of audio channels per sample. There are two factors
|
||||
to consider: hardware capability and desired mixing.
|
||||
|
||||
@param hardware The number of channels supported by the sound system
|
||||
@param stereo Whether to output the internal sound signals into 1
|
||||
or 2 channels
|
||||
|
||||
@return Status of the channel configuration used
|
||||
*/
|
||||
std::string channels(unsigned int hardware, bool stereo);
|
||||
|
||||
public:
|
||||
/**
|
||||
Sets the specified sound register to the given value
|
||||
|
||||
@param address Register address
|
||||
@param value Value to store in the register
|
||||
*/
|
||||
void set(unsigned short address, unsigned char value);
|
||||
|
||||
/**
|
||||
Gets the specified sound register's value
|
||||
|
||||
@param address Register address
|
||||
*/
|
||||
unsigned char get(unsigned short address) const;
|
||||
|
||||
/**
|
||||
Create sound samples based on the current sound register settings
|
||||
in the specified buffer. NOTE: If channels is set to stereo then
|
||||
the buffer will need to be twice as long as the number of samples.
|
||||
|
||||
@param buffer The location to store generated samples
|
||||
@param samples The number of samples to generate
|
||||
*/
|
||||
void process(short* buffer, unsigned int samples, DivDispatchOscBuffer** oscBuf=NULL);
|
||||
|
||||
/**
|
||||
Set the volume of the samples created (0-100)
|
||||
*/
|
||||
void volume(unsigned int percent);
|
||||
|
||||
private:
|
||||
void polyInit(unsigned char* poly, int size, int f0, int f1);
|
||||
|
||||
private:
|
||||
// Definitions for AUDCx (15, 16)
|
||||
enum AUDCxRegister
|
||||
{
|
||||
SET_TO_1 = 0x00, // 0000
|
||||
POLY4 = 0x01, // 0001
|
||||
DIV31_POLY4 = 0x02, // 0010
|
||||
POLY5_POLY4 = 0x03, // 0011
|
||||
PURE1 = 0x04, // 0100
|
||||
PURE2 = 0x05, // 0101
|
||||
DIV31_PURE = 0x06, // 0110
|
||||
POLY5_2 = 0x07, // 0111
|
||||
POLY9 = 0x08, // 1000
|
||||
POLY5 = 0x09, // 1001
|
||||
DIV31_POLY5 = 0x0a, // 1010
|
||||
POLY5_POLY5 = 0x0b, // 1011
|
||||
DIV3_PURE = 0x0c, // 1100
|
||||
DIV3_PURE2 = 0x0d, // 1101
|
||||
DIV93_PURE = 0x0e, // 1110
|
||||
POLY5_DIV3 = 0x0f // 1111
|
||||
};
|
||||
|
||||
enum {
|
||||
POLY4_SIZE = 0x000f,
|
||||
POLY5_SIZE = 0x001f,
|
||||
POLY9_SIZE = 0x01ff,
|
||||
DIV3_MASK = 0x0c,
|
||||
AUDV_SHIFT = 10 // shift 2 positions for AUDV,
|
||||
// then another 8 for 16-bit sound
|
||||
};
|
||||
|
||||
enum ChannelMode {
|
||||
Hardware2Mono, // mono sampling with 2 hardware channels
|
||||
Hardware2Stereo, // stereo sampling with 2 hardware channels
|
||||
Hardware1 // mono/stereo sampling with only 1 hardware channel
|
||||
};
|
||||
|
||||
private:
|
||||
// Structures to hold the 6 tia sound control bytes
|
||||
unsigned char myAUDC[2]; // AUDCx (15, 16)
|
||||
unsigned char myAUDF[2]; // AUDFx (17, 18)
|
||||
short myAUDV[2]; // AUDVx (19, 1A)
|
||||
|
||||
short myVolume[2]; // Last output volume for each channel
|
||||
|
||||
unsigned char myP4[2]; // Position pointer for the 4-bit POLY array
|
||||
unsigned char myP5[2]; // Position pointer for the 5-bit POLY array
|
||||
unsigned short myP9[2]; // Position pointer for the 9-bit POLY array
|
||||
|
||||
unsigned char myDivNCnt[2]; // Divide by n counter. one for each channel
|
||||
unsigned char myDivNMax[2]; // Divide by n maximum, one for each channel
|
||||
unsigned char myDiv3Cnt[2]; // Div 3 counter, used for POLY5_DIV3 mode
|
||||
|
||||
ChannelMode myChannelMode;
|
||||
int myOutputFrequency;
|
||||
unsigned int myVolumePercentage;
|
||||
|
||||
/*
|
||||
Initialize the bit patterns for the polynomials (at runtime).
|
||||
|
||||
The 4bit and 5bit patterns are the identical ones used in the tia chip.
|
||||
Though the patterns could be packed with 8 bits per byte, using only a
|
||||
single bit per byte keeps the math simple, which is important for
|
||||
efficient processing.
|
||||
*/
|
||||
unsigned char Bit4[POLY4_SIZE];
|
||||
unsigned char Bit5[POLY5_SIZE];
|
||||
unsigned char Bit9[POLY9_SIZE];
|
||||
|
||||
/*
|
||||
The 'Div by 31' counter is treated as another polynomial because of
|
||||
the way it operates. It does not have a 50% duty cycle, but instead
|
||||
has a 13:18 ratio (of course, 13+18 = 31). This could also be
|
||||
implemented by using counters.
|
||||
*/
|
||||
static const unsigned char Div31[POLY5_SIZE];
|
||||
|
||||
private:
|
||||
// Following constructors and assignment operators not supported
|
||||
TIASound(const TIASound&) = delete;
|
||||
TIASound(TIASound&&) = delete;
|
||||
TIASound& operator=(const TIASound&) = delete;
|
||||
TIASound& operator=(TIASound&&) = delete;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,219 +0,0 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2016 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//
|
||||
// $Id: TIATables.hxx 3239 2015-12-29 19:22:46Z stephena $
|
||||
//============================================================================
|
||||
|
||||
#ifndef TIA_TABLES_HXX
|
||||
#define TIA_TABLES_HXX
|
||||
|
||||
enum TIABit {
|
||||
P0Bit = 0x01, // Bit for Player 0
|
||||
M0Bit = 0x02, // Bit for Missle 0
|
||||
P1Bit = 0x04, // Bit for Player 1
|
||||
M1Bit = 0x08, // Bit for Missle 1
|
||||
BLBit = 0x10, // Bit for Ball
|
||||
PFBit = 0x20, // Bit for Playfield
|
||||
ScoreBit = 0x40, // Bit for Playfield score mode
|
||||
PriorityBit = 0x80 // Bit for Playfield priority
|
||||
};
|
||||
|
||||
enum TIAColor {
|
||||
BKColor = 0, // Color index for Background
|
||||
PFColor = 1, // Color index for Playfield
|
||||
P0Color = 2, // Color index for Player 0
|
||||
P1Color = 3, // Color index for Player 1
|
||||
M0Color = 4, // Color index for Missle 0
|
||||
M1Color = 5, // Color index for Missle 1
|
||||
BLColor = 6, // Color index for Ball
|
||||
HBLANKColor = 7 // Color index for HMove blank area
|
||||
};
|
||||
|
||||
enum CollisionBit
|
||||
{
|
||||
Cx_M0P1 = 1 << 0, // Missle0 - Player1 collision
|
||||
Cx_M0P0 = 1 << 1, // Missle0 - Player0 collision
|
||||
Cx_M1P0 = 1 << 2, // Missle1 - Player0 collision
|
||||
Cx_M1P1 = 1 << 3, // Missle1 - Player1 collision
|
||||
Cx_P0PF = 1 << 4, // Player0 - Playfield collision
|
||||
Cx_P0BL = 1 << 5, // Player0 - Ball collision
|
||||
Cx_P1PF = 1 << 6, // Player1 - Playfield collision
|
||||
Cx_P1BL = 1 << 7, // Player1 - Ball collision
|
||||
Cx_M0PF = 1 << 8, // Missle0 - Playfield collision
|
||||
Cx_M0BL = 1 << 9, // Missle0 - Ball collision
|
||||
Cx_M1PF = 1 << 10, // Missle1 - Playfield collision
|
||||
Cx_M1BL = 1 << 11, // Missle1 - Ball collision
|
||||
Cx_BLPF = 1 << 12, // Ball - Playfield collision
|
||||
Cx_P0P1 = 1 << 13, // Player0 - Player1 collision
|
||||
Cx_M0M1 = 1 << 14 // Missle0 - Missle1 collision
|
||||
};
|
||||
|
||||
// TIA Write/Read register names
|
||||
enum TIARegister {
|
||||
VSYNC = 0x00, // Write: vertical sync set-clear (D1)
|
||||
VBLANK = 0x01, // Write: vertical blank set-clear (D7-6,D1)
|
||||
WSYNC = 0x02, // Write: wait for leading edge of hrz. blank (strobe)
|
||||
RSYNC = 0x03, // Write: reset hrz. sync counter (strobe)
|
||||
NUSIZ0 = 0x04, // Write: number-size player-missle 0 (D5-0)
|
||||
NUSIZ1 = 0x05, // Write: number-size player-missle 1 (D5-0)
|
||||
COLUP0 = 0x06, // Write: color-lum player 0 (D7-1)
|
||||
COLUP1 = 0x07, // Write: color-lum player 1 (D7-1)
|
||||
COLUPF = 0x08, // Write: color-lum playfield (D7-1)
|
||||
COLUBK = 0x09, // Write: color-lum background (D7-1)
|
||||
CTRLPF = 0x0a, // Write: cntrl playfield ballsize & coll. (D5-4,D2-0)
|
||||
REFP0 = 0x0b, // Write: reflect player 0 (D3)
|
||||
REFP1 = 0x0c, // Write: reflect player 1 (D3)
|
||||
PF0 = 0x0d, // Write: playfield register byte 0 (D7-4)
|
||||
PF1 = 0x0e, // Write: playfield register byte 1 (D7-0)
|
||||
PF2 = 0x0f, // Write: playfield register byte 2 (D7-0)
|
||||
RESP0 = 0x10, // Write: reset player 0 (strobe)
|
||||
RESP1 = 0x11, // Write: reset player 1 (strobe)
|
||||
RESM0 = 0x12, // Write: reset missle 0 (strobe)
|
||||
RESM1 = 0x13, // Write: reset missle 1 (strobe)
|
||||
RESBL = 0x14, // Write: reset ball (strobe)
|
||||
AUDC0 = 0x15, // Write: audio control 0 (D3-0)
|
||||
AUDC1 = 0x16, // Write: audio control 1 (D4-0)
|
||||
AUDF0 = 0x17, // Write: audio frequency 0 (D4-0)
|
||||
AUDF1 = 0x18, // Write: audio frequency 1 (D3-0)
|
||||
AUDV0 = 0x19, // Write: audio volume 0 (D3-0)
|
||||
AUDV1 = 0x1a, // Write: audio volume 1 (D3-0)
|
||||
GRP0 = 0x1b, // Write: graphics player 0 (D7-0)
|
||||
GRP1 = 0x1c, // Write: graphics player 1 (D7-0)
|
||||
ENAM0 = 0x1d, // Write: graphics (enable) missle 0 (D1)
|
||||
ENAM1 = 0x1e, // Write: graphics (enable) missle 1 (D1)
|
||||
ENABL = 0x1f, // Write: graphics (enable) ball (D1)
|
||||
HMP0 = 0x20, // Write: horizontal motion player 0 (D7-4)
|
||||
HMP1 = 0x21, // Write: horizontal motion player 1 (D7-4)
|
||||
HMM0 = 0x22, // Write: horizontal motion missle 0 (D7-4)
|
||||
HMM1 = 0x23, // Write: horizontal motion missle 1 (D7-4)
|
||||
HMBL = 0x24, // Write: horizontal motion ball (D7-4)
|
||||
VDELP0 = 0x25, // Write: vertical delay player 0 (D0)
|
||||
VDELP1 = 0x26, // Write: vertical delay player 1 (D0)
|
||||
VDELBL = 0x27, // Write: vertical delay ball (D0)
|
||||
RESMP0 = 0x28, // Write: reset missle 0 to player 0 (D1)
|
||||
RESMP1 = 0x29, // Write: reset missle 1 to player 1 (D1)
|
||||
HMOVE = 0x2a, // Write: apply horizontal motion (strobe)
|
||||
HMCLR = 0x2b, // Write: clear horizontal motion registers (strobe)
|
||||
CXCLR = 0x2c, // Write: clear collision latches (strobe)
|
||||
|
||||
CXM0P = 0x00, // Read collision: D7=(M0,P1); D6=(M0,P0)
|
||||
CXM1P = 0x01, // Read collision: D7=(M1,P0); D6=(M1,P1)
|
||||
CXP0FB = 0x02, // Read collision: D7=(P0,PF); D6=(P0,BL)
|
||||
CXP1FB = 0x03, // Read collision: D7=(P1,PF); D6=(P1,BL)
|
||||
CXM0FB = 0x04, // Read collision: D7=(M0,PF); D6=(M0,BL)
|
||||
CXM1FB = 0x05, // Read collision: D7=(M1,PF); D6=(M1,BL)
|
||||
CXBLPF = 0x06, // Read collision: D7=(BL,PF); D6=(unused)
|
||||
CXPPMM = 0x07, // Read collision: D7=(P0,P1); D6=(M0,M1)
|
||||
INPT0 = 0x08, // Read pot port: D7
|
||||
INPT1 = 0x09, // Read pot port: D7
|
||||
INPT2 = 0x0a, // Read pot port: D7
|
||||
INPT3 = 0x0b, // Read pot port: D7
|
||||
INPT4 = 0x0c, // Read P1 joystick trigger: D7
|
||||
INPT5 = 0x0d // Read P2 joystick trigger: D7
|
||||
};
|
||||
|
||||
/**
|
||||
The TIA class uses some static tables that aren't dependent on the actual
|
||||
TIA state. For code organization, it's better to place that functionality
|
||||
here.
|
||||
|
||||
@author Stephen Anthony
|
||||
@version $Id: TIATables.hxx 3239 2015-12-29 19:22:46Z stephena $
|
||||
*/
|
||||
class TIATables
|
||||
{
|
||||
public:
|
||||
/**
|
||||
Compute all static tables used by the TIA
|
||||
*/
|
||||
static void computeAllTables();
|
||||
|
||||
// Player mask table
|
||||
// [suppress mode][nusiz][pixel]
|
||||
static unsigned char PxMask[2][8][320];
|
||||
|
||||
// Missle mask table (entries are true or false)
|
||||
// [number][size][pixel]
|
||||
// There are actually only 4 possible size combinations on a real system
|
||||
// The fifth size is used for simulating the starfield effect in
|
||||
// Cosmic Ark and Stay Frosty
|
||||
static unsigned char MxMask[8][5][320];
|
||||
|
||||
// Ball mask table (entries are true or false)
|
||||
// [size][pixel]
|
||||
static unsigned char BLMask[4][320];
|
||||
|
||||
// Playfield mask table for reflected and non-reflected playfields
|
||||
// [reflect, pixel]
|
||||
static unsigned int PFMask[2][160];
|
||||
|
||||
// A mask table which can be used when an object is disabled
|
||||
static unsigned char DisabledMask[640];
|
||||
|
||||
// Used to set the collision register to the correct value
|
||||
static unsigned short CollisionMask[64];
|
||||
|
||||
// Indicates the update delay associated with poking at a TIA address
|
||||
static const short PokeDelay[64];
|
||||
|
||||
#if 0
|
||||
// Used to convert value written in a motion register into
|
||||
// its internal representation
|
||||
static const int CompleteMotion[76][16];
|
||||
#endif
|
||||
|
||||
// Indicates if HMOVE blanks should occur for the corresponding cycle
|
||||
static const bool HMOVEBlankEnableCycles[76];
|
||||
|
||||
// Used to reflect a players graphics
|
||||
static unsigned char GRPReflect[256];
|
||||
|
||||
// Indicates if player is being reset during delay, display or other times
|
||||
// [nusiz][old pixel][new pixel]
|
||||
static signed char PxPosResetWhen[8][160][160];
|
||||
|
||||
private:
|
||||
// Compute the collision decode table
|
||||
static void buildCollisionMaskTable();
|
||||
|
||||
// Compute the player mask table
|
||||
static void buildPxMaskTable();
|
||||
|
||||
// Compute the missle mask table
|
||||
static void buildMxMaskTable();
|
||||
|
||||
// Compute the ball mask table
|
||||
static void buildBLMaskTable();
|
||||
|
||||
// Compute playfield mask table
|
||||
static void buildPFMaskTable();
|
||||
|
||||
// Compute the player reflect table
|
||||
static void buildGRPReflectTable();
|
||||
|
||||
// Compute the player position reset when table
|
||||
static void buildPxPosResetWhenTable();
|
||||
|
||||
private:
|
||||
// Following constructors and assignment operators not supported
|
||||
TIATables() = delete;
|
||||
TIATables(const TIATables&) = delete;
|
||||
TIATables(TIATables&&) = delete;
|
||||
TIATables& operator=(const TIATables&) = delete;
|
||||
TIATables& operator=(TIATables&&) = delete;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -22,7 +22,7 @@
|
|||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#define rWrite(a,v) if (!skipRegisterWrites) {tia.set(a,v); regPool[((a)-0x15)&0x0f]=v; if (dumpWrites) {addWrite(a,v);} }
|
||||
#define rWrite(a,v) if (!skipRegisterWrites) {tia.write(a,v); regPool[((a)-0x15)&0x0f]=v; if (dumpWrites) {addWrite(a,v);} }
|
||||
|
||||
const char* regCheatSheetTIA[]={
|
||||
"AUDC0", "15",
|
||||
|
|
@ -39,7 +39,10 @@ const char** DivPlatformTIA::getRegisterSheet() {
|
|||
}
|
||||
|
||||
void DivPlatformTIA::acquire(short* bufL, short* bufR, size_t start, size_t len) {
|
||||
tia.process(bufL+start,len,oscBuf);
|
||||
for (size_t h=start; h<start+len; h++) {
|
||||
tia.tick();
|
||||
bufL[h]=tia.myCurrentSample[0];
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char DivPlatformTIA::dealWithFreq(unsigned char shape, int base, int pitch) {
|
||||
|
|
@ -300,7 +303,7 @@ int DivPlatformTIA::getRegisterPoolSize() {
|
|||
}
|
||||
|
||||
void DivPlatformTIA::reset() {
|
||||
tia.reset();
|
||||
tia.reset(false);
|
||||
memset(regPool,0,16);
|
||||
for (int i=0; i<2; i++) {
|
||||
chan[i]=DivPlatformTIA::Channel();
|
||||
|
|
@ -333,9 +336,9 @@ void DivPlatformTIA::poke(std::vector<DivRegWrite>& wlist) {
|
|||
|
||||
void DivPlatformTIA::setFlags(unsigned int flags) {
|
||||
if (flags&1) {
|
||||
rate=31250;
|
||||
rate=COLOR_PAL*4.0/5.0;
|
||||
} else {
|
||||
rate=31468;
|
||||
rate=COLOR_NTSC;
|
||||
}
|
||||
chipClock=rate;
|
||||
for (int i=0; i<2; i++) {
|
||||
|
|
@ -351,7 +354,6 @@ int DivPlatformTIA::init(DivEngine* p, int channels, int sugRate, unsigned int f
|
|||
isMuted[i]=false;
|
||||
oscBuf[i]=new DivDispatchOscBuffer;
|
||||
}
|
||||
tia.channels(1,false);
|
||||
setFlags(flags);
|
||||
reset();
|
||||
return 2;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
#include "../dispatch.h"
|
||||
#include "../macroInt.h"
|
||||
#include <queue>
|
||||
#include "sound/tia/TIASnd.h"
|
||||
#include "sound/tia/Audio.h"
|
||||
|
||||
class DivPlatformTIA: public DivDispatch {
|
||||
protected:
|
||||
|
|
@ -42,7 +42,7 @@ class DivPlatformTIA: public DivDispatch {
|
|||
Channel chan[2];
|
||||
DivDispatchOscBuffer* oscBuf[2];
|
||||
bool isMuted[2];
|
||||
TIASound tia;
|
||||
TIA::Audio tia;
|
||||
unsigned char regPool[16];
|
||||
friend void putDispatchChan(void*,int,int);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue