AppleWin/source/MockingboardCardManager.cpp
2023-01-29 13:37:07 +00:00

449 lines
13 KiB
C++

/*
AppleWin : An Apple //e emulator for Windows
Copyright (C) 1994-1996, Michael O'Brien
Copyright (C) 1999-2001, Oliver Schmidt
Copyright (C) 2002-2005, Tom Charlesworth
Copyright (C) 2006-2022, Tom Charlesworth, Michael Pohoreski, Nick Westgate
AppleWin is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
AppleWin is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with AppleWin; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Description: Mockingboard/Phasor Card Manager
*
* Author: Various
*
*/
#include "StdAfx.h"
#include "MockingboardCardManager.h"
#include "Core.h"
#include "CardManager.h"
#include "CPU.h"
#include "Mockingboard.h"
#include "MockingboardDefs.h"
#include "Riff.h"
//#define DBG_MB_UPDATE
bool MockingboardCardManager::IsMockingboard(UINT slot)
{
SS_CARDTYPE type = GetCardMgr().QuerySlot(slot);
return type == CT_MockingboardC || type == CT_Phasor;
}
void MockingboardCardManager::ReinitializeClock(void)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).ReinitializeClock();
}
}
void MockingboardCardManager::InitializeForLoadingSnapshot(void)
{
if (g_bDisableDirectSound || g_bDisableDirectSoundMockingboard)
return;
if (!m_mockingboardVoice.lpDSBvoice)
return;
DSVoiceStop(&m_mockingboardVoice); // Reason: 'MB voice is playing' then loading a save-state where 'no MB present' (GH#609)
}
void MockingboardCardManager::MuteControl(bool mute)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).MuteControl(mute);
}
if (mute)
{
if (m_mockingboardVoice.bActive && !m_mockingboardVoice.bMute)
{
m_mockingboardVoice.lpDSBvoice->SetVolume(DSBVOLUME_MIN);
m_mockingboardVoice.bMute = true;
}
}
else
{
if (m_mockingboardVoice.bActive && m_mockingboardVoice.bMute)
{
m_mockingboardVoice.lpDSBvoice->SetVolume(m_mockingboardVoice.nVolume);
m_mockingboardVoice.bMute = false;
}
}
}
void MockingboardCardManager::SetCumulativeCycles(void)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).SetCumulativeCycles();
}
}
void MockingboardCardManager::UpdateCycles(ULONG executedCycles)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).UpdateCycles(executedCycles);
}
}
// Called from class SY6522
void MockingboardCardManager::UpdateIRQ(void)
{
bool irq = false;
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
irq |= dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).Is6522IRQ();
}
if (irq)
CpuIrqAssert(IS_6522);
else
CpuIrqDeassert(IS_6522);
}
bool MockingboardCardManager::IsActive(void)
{
if (!m_mockingboardVoice.bActive)
return false;
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
if (dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).IsActive())
return true; // if any card is true then the condition for active is true
}
return false;
}
DWORD MockingboardCardManager::GetVolume(void)
{
return m_userVolume;
}
void MockingboardCardManager::SetVolume(DWORD volume, DWORD volumeMax)
{
m_userVolume = volume;
m_mockingboardVoice.dwUserVolume = volume;
m_mockingboardVoice.nVolume = NewVolume(volume, volumeMax);
if (m_mockingboardVoice.bActive && !m_mockingboardVoice.bMute)
m_mockingboardVoice.lpDSBvoice->SetVolume(m_mockingboardVoice.nVolume);
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).SetVolume(volume, volumeMax);
}
}
#ifdef _DEBUG
void MockingboardCardManager::CheckCumulativeCycles(void)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).CheckCumulativeCycles();
}
}
void MockingboardCardManager::Get6522IrqDescription(std::string& desc)
{
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).Get6522IrqDescription(desc);
}
}
#endif
// Called by CardManager::Destroy()
void MockingboardCardManager::Destroy(void)
{
// NB. All cards (including any Mockingboard cards) have just been destroyed by CardManager
if (m_mockingboardVoice.lpDSBvoice && m_mockingboardVoice.bActive)
DSVoiceStop(&m_mockingboardVoice);
DSReleaseSoundBuffer(&m_mockingboardVoice);
}
// Called by ContinueExecution() at the end of every execution period (~1000 cycles or ~3 cycles when MODE_STEPPING)
// NB. Required for FT's TEST LAB #1 player
void MockingboardCardManager::Update(const ULONG executedCycles)
{
// NB. CardManager has just called each card's Update()
bool active = false;
for (UINT i = SLOT0; i < NUM_SLOTS; i++)
{
if (IsMockingboard(i))
active |= dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(i)).IsAnyTimer1Active();
}
if (active)
return;
// No 6522 TIMER1's are active, so periodically update AY8913's here...
const UINT kCyclesPerAudioFrame = 1000;
m_cyclesThisAudioFrame += executedCycles;
if (m_cyclesThisAudioFrame < kCyclesPerAudioFrame)
return;
m_cyclesThisAudioFrame %= kCyclesPerAudioFrame;
UpdateSoundBuffer();
}
// Called by:
// . MB_SyncEventCallback() on a TIMER1 (not TIMER2) underflow - when IsAnyTimer1Active() == true
// . Update() - when IsAnyTimer1Active() == false
void MockingboardCardManager::UpdateSoundBuffer(void)
{
#ifdef LOG_PERF_TIMINGS
extern UINT64 g_timeMB_NoTimer;
extern UINT64 g_timeMB_Timer;
PerfMarker perfMarker(!IsAnyTimer1Active() ? g_timeMB_NoTimer : g_timeMB_Timer);
#endif
if (!m_mockingboardVoice.lpDSBvoice)
{
if (g_bDisableDirectSound || g_bDisableDirectSoundMockingboard)
return;
if (!Init())
return;
}
if (!m_mockingboardVoice.bActive)
{
// Sound buffer may have been stopped by MB_InitializeForLoadingSnapshot().
// NB. DSZeroVoiceBuffer() also zeros the sound buffer, so it's better than directly calling IDirectSoundBuffer::Play():
// - without zeroing, then the previous sound buffer can be heard for a fraction of a second
// - eg. when doing Mockingboard playback, then loading a save-state which is also doing Mockingboard playback
DSZeroVoiceBuffer(&m_mockingboardVoice, SOUNDBUFFER_SIZE); // ... and Play()
}
UINT numSamples = GenerateAllSoundData();
if (numSamples)
MixAllAndCopyToRingBuffer(numSamples);
}
bool MockingboardCardManager::Init(void)
{
if (!g_bDSAvailable)
return false;
const DWORD SAMPLE_RATE = 44100; // Use a base freq so that DirectX (or sound h/w) doesn't have to up/down-sample
HRESULT hr = DSGetSoundBuffer(&m_mockingboardVoice, DSBCAPS_CTRLVOLUME, SOUNDBUFFER_SIZE, SAMPLE_RATE, NUM_MB_CHANNELS, "MB");
LogFileOutput("MBCardMgr: DSGetSoundBuffer(), hr=0x%08X\n", hr);
if (FAILED(hr))
{
LogFileOutput("MBCardMgr: DSGetSoundBuffer failed (%08X)\n", hr);
return false;
}
bool bRes = DSZeroVoiceBuffer(&m_mockingboardVoice, SOUNDBUFFER_SIZE); // ... and Play()
LogFileOutput("MBCardMgr: DSZeroVoiceBuffer(), res=%d\n", bRes ? 1 : 0);
if (!bRes)
return false;
m_mockingboardVoice.bActive = true;
// Volume might've been setup from value in Registry
if (!m_mockingboardVoice.nVolume)
m_mockingboardVoice.nVolume = DSBVOLUME_MAX;
hr = m_mockingboardVoice.lpDSBvoice->SetVolume(m_mockingboardVoice.nVolume);
LogFileOutput("MBCardMgr: SetVolume(), hr=0x%08X\n", hr);
return true;
}
UINT MockingboardCardManager::GenerateAllSoundData(void)
{
UINT nNumSamples = 0;
for (UINT slot = SLOT0; slot < NUM_SLOTS; slot++)
{
if (!IsMockingboard(slot))
continue;
MockingboardCard& MB = dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(slot));
MB.SetNumSamplesError(m_numSamplesError);
nNumSamples = MB.MB_Update();
m_numSamplesError = MB.GetNumSamplesError();
}
//
DWORD dwCurrentPlayCursor, dwCurrentWriteCursor;
HRESULT hr = m_mockingboardVoice.lpDSBvoice->GetCurrentPosition(&dwCurrentPlayCursor, &dwCurrentWriteCursor);
if (FAILED(hr))
return 0;
if (m_byteOffset == (DWORD)-1)
{
// First time in this func
m_byteOffset = dwCurrentWriteCursor;
}
else
{
// Check that our offset isn't between Play & Write positions
if (dwCurrentWriteCursor > dwCurrentPlayCursor)
{
// |-----PxxxxxW-----|
if ((m_byteOffset > dwCurrentPlayCursor) && (m_byteOffset < dwCurrentWriteCursor))
{
#ifdef DBG_MB_UPDATE
double fTicksSecs = (double)GetTickCount() / 1000.0;
LogOutput("%010.3f: [MBUpdt] PC=%08X, WC=%08X, Diff=%08X, Off=%08X, NS=%08X xxx\n", fTicksSecs, dwCurrentPlayCursor, dwCurrentWriteCursor, dwCurrentWriteCursor - dwCurrentPlayCursor, dwByteOffset, nNumSamples);
#endif
m_byteOffset = dwCurrentWriteCursor;
m_numSamplesError = 0;
}
}
else
{
// |xxW----------Pxxx|
if ((m_byteOffset > dwCurrentPlayCursor) || (m_byteOffset < dwCurrentWriteCursor))
{
#ifdef DBG_MB_UPDATE
double fTicksSecs = (double)GetTickCount() / 1000.0;
LogOutput("%010.3f: [MBUpdt] PC=%08X, WC=%08X, Diff=%08X, Off=%08X, NS=%08X XXX\n", fTicksSecs, dwCurrentPlayCursor, dwCurrentWriteCursor, dwCurrentWriteCursor - dwCurrentPlayCursor, dwByteOffset, nNumSamples);
#endif
m_byteOffset = dwCurrentWriteCursor;
m_numSamplesError = 0;
}
}
}
int nBytesRemaining = m_byteOffset - dwCurrentPlayCursor;
if (nBytesRemaining < 0)
nBytesRemaining += SOUNDBUFFER_SIZE;
// Calc correction factor so that play-buffer doesn't under/overflow
const int nErrorInc = SoundCore_GetErrorInc();
if (nBytesRemaining < SOUNDBUFFER_SIZE / 4)
m_numSamplesError += nErrorInc; // < 0.25 of buffer remaining
else if (nBytesRemaining > SOUNDBUFFER_SIZE / 2)
m_numSamplesError -= nErrorInc; // > 0.50 of buffer remaining
else
m_numSamplesError = 0; // Acceptable amount of data in buffer
#ifdef DBG_MB_UPDATE
double fTicksSecs = (double)GetTickCount() / 1000.0;
LogOutput("%010.3f: [MBUpdt] PC=%08X, WC=%08X, Diff=%08X, Off=%08X, NS=%08X, NSE=%08X, Interval=%f\n", fTicksSecs, dwCurrentPlayCursor, dwCurrentWriteCursor, dwCurrentWriteCursor - dwCurrentPlayCursor, dwByteOffset, nNumSamples, nNumSamplesError, updateInterval);
#endif
return nNumSamples;
}
void MockingboardCardManager::MixAllAndCopyToRingBuffer(UINT nNumSamples)
{
// const double fAttenuation = g_bPhasorEnable ? 2.0 / 3.0 : 1.0;
const double fAttenuation = true ? 2.0 / 3.0 : 1.0;
short** slotAYVoiceBuffers[NUM_SLOTS] = {0};
for (UINT slot = SLOT0; slot < NUM_SLOTS; slot++)
{
if (IsMockingboard(slot))
slotAYVoiceBuffers[slot] = dynamic_cast<MockingboardCard&>(GetCardMgr().GetRef(slot)).GetVoiceBuffers();
}
for (UINT i = 0; i < nNumSamples; i++)
{
// Mockingboard stereo (all voices on an AY8910 wire-or'ed together)
// L = Address.b7=0, R = Address.b7=1
int nDataL = 0, nDataR = 0;
for (UINT slot = SLOT0; slot < NUM_SLOTS; slot++)
{
if (!slotAYVoiceBuffers[slot])
continue;
for (UINT j = 0; j < NUM_VOICES_PER_AY8913; j++)
{
short** ppAYVoiceBuffer = slotAYVoiceBuffers[slot];
// Regular MB-C AY's
nDataL += (int)((double)ppAYVoiceBuffer[0 * NUM_VOICES_PER_AY8913 + j][i] * fAttenuation);
nDataR += (int)((double)ppAYVoiceBuffer[2 * NUM_VOICES_PER_AY8913 + j][i] * fAttenuation);
// Extra Phasor AY's
nDataL += (int)((double)ppAYVoiceBuffer[1 * NUM_VOICES_PER_AY8913 + j][i] * fAttenuation);
nDataR += (int)((double)ppAYVoiceBuffer[3 * NUM_VOICES_PER_AY8913 + j][i] * fAttenuation);
}
}
// Cap the superpositioned output
if (nDataL < WAVE_DATA_MIN)
nDataL = WAVE_DATA_MIN;
else if (nDataL > WAVE_DATA_MAX)
nDataL = WAVE_DATA_MAX;
if (nDataR < WAVE_DATA_MIN)
nDataR = WAVE_DATA_MIN;
else if (nDataR > WAVE_DATA_MAX)
nDataR = WAVE_DATA_MAX;
m_mixBuffer[i * NUM_MB_CHANNELS + 0] = (short)nDataL; // L
m_mixBuffer[i * NUM_MB_CHANNELS + 1] = (short)nDataR; // R
}
//
DWORD dwDSLockedBufferSize0, dwDSLockedBufferSize1;
SHORT* pDSLockedBuffer0, * pDSLockedBuffer1;
HRESULT hr = DSGetLock(m_mockingboardVoice.lpDSBvoice,
m_byteOffset, (DWORD)nNumSamples * sizeof(short) * NUM_MB_CHANNELS,
&pDSLockedBuffer0, &dwDSLockedBufferSize0,
&pDSLockedBuffer1, &dwDSLockedBufferSize1);
if (FAILED(hr))
return;
memcpy(pDSLockedBuffer0, &m_mixBuffer[0], dwDSLockedBufferSize0);
if (pDSLockedBuffer1)
memcpy(pDSLockedBuffer1, &m_mixBuffer[dwDSLockedBufferSize0 / sizeof(short)], dwDSLockedBufferSize1);
// Commit sound buffer
hr = m_mockingboardVoice.lpDSBvoice->Unlock((void*)pDSLockedBuffer0, dwDSLockedBufferSize0,
(void*)pDSLockedBuffer1, dwDSLockedBufferSize1);
m_byteOffset = (m_byteOffset + (DWORD)nNumSamples * sizeof(short) * NUM_MB_CHANNELS) % SOUNDBUFFER_SIZE;
if (m_outputToRiff)
RiffPutSamples(&m_mixBuffer[0], nNumSamples);
}