piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-23 06:09:50 -06:00
Code Issues Packages Projects Releases Wiki Activity

Sound System Rework: Phase 2

Browse Source 
. Performance boost
  (Completely non-blocking between Sound thread and CPU thread, in the meantime keeping them thread safe)

. Both 32KHz & 48KHz sound can be handled properly now
  (But up-sampling is still not implemented, and I don't think any game requires it.)

. Strategy adjustment
  When your PC is *NOT* capable to run the game at 100%:
  >> DSound    Could yield more fluent sound than OpenAL sometimes, but you will lose the sync between video & audio (since audio is played before video to guarantee fluency)
  >> OpenAL    Ensures video & audio are always sync'ed, but sound could be intermittent(to let slow video catch up)

. Changed default frame limit to: Auto
  (Somehow this can dramatically decrease the chance of wiimote desync in game NSMB)

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4724 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
ayuanx
2009-12-23 15:34:14 +00:00
parent 0d0a7c515f
commit 9eea60ca69
27 changed files with 358 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
Source/Core/AudioCommon/Src/AudioCommon.h
View File

@ -30,6 +30,31 @@ extern DSPInitialize g_dspInitialize;
extern SoundStream *soundStream;
extern AudioCommonConfig ac_Config;
// UDSPControl
union UDSPControl
{
u16 Hex;
struct
{
unsigned DSPReset : 1; // Write 1 to reset and waits for 0
unsigned DSPAssertInt : 1;
unsigned DSPHalt : 1;
unsigned AI : 1;
unsigned AI_mask : 1;
unsigned ARAM : 1;
unsigned ARAM_mask : 1;
unsigned DSP : 1;
unsigned DSP_mask : 1;
unsigned ARAM_DMAState : 1; // DSPGetDMAStatus() uses this flag
unsigned DSPInitCode : 1;
unsigned DSPInit : 1; // DSPInit() writes to this flag
unsigned pad : 4;
};
UDSPControl(u16 _Hex = 0) : Hex(_Hex) {}
};
namespace AudioCommon
{
SoundStream *InitSoundStream(CMixer *mixer = NULL);

9
Source/Core/AudioCommon/Src/DSoundStream.cpp
View File

@ -111,13 +111,11 @@ void DSound::SoundLoop()
int numBytesToRender = FIX128(ModBufferSize(currentPos - lastPos));
if (numBytesToRender >= 256)
{
if (numBytesToRender > sizeof(realtimeBuffer))
if (numBytesToRender > sizeof(realtimeBuffer) * sizeof(short))
PanicAlert("soundThread: too big render call");
m_mixer->Mix(realtimeBuffer, numBytesToRender >> 2);
m_mixer->Mix(realtimeBuffer, numBytesToRender / 4);
WriteDataToBuffer(lastPos, (char*)realtimeBuffer, numBytesToRender);
currentPos = ModBufferSize(lastPos + numBytesToRender);
totalRenderedBytes += numBytesToRender;
lastPos = currentPos;
lastPos = ModBufferSize(lastPos + numBytesToRender);
}
soundCriticalSection.Leave();
soundSyncEvent.Wait();
@ -142,7 +140,6 @@ bool DSound::Start()
dsBuffer->Lock(0, bufferSize, (void* *)&p1, &num1, 0, 0, 0);
memset(p1, 0, num1);
dsBuffer->Unlock(p1, num1, 0, 0);
totalRenderedBytes = -bufferSize;
thread = new Common::Thread(soundThread, (void *)this);
return true;
}

16
Source/Core/AudioCommon/Src/DSoundStream.h
View File

@ -25,8 +25,7 @@
#include <mmsystem.h>
#include <dsound.h>
#define BUFSIZE 32768
#define MAXWAIT 70 // miliseconds
#define BUFSIZE (1024 * 8 * 4)
#endif
class DSound : public SoundStream
@ -41,31 +40,30 @@ class DSound : public SoundStream
IDirectSoundBuffer* dsBuffer;
int bufferSize; //i bytes
int totalRenderedBytes;
int m_volume;
// playback position
int currentPos;
int lastPos;
short realtimeBuffer[1024 * 1024];
short realtimeBuffer[BUFSIZE / sizeof(short)];
inline int FIX128(int x) {
inline int FIX128(int x)
{
return x & (~127);
}
inline int ModBufferSize(int x) {
inline int ModBufferSize(int x)
{
return (x + bufferSize) % bufferSize;
}
bool CreateBuffer();
bool WriteDataToBuffer(DWORD dwOffset, char* soundData,
DWORD dwSoundBytes);
bool WriteDataToBuffer(DWORD dwOffset, char* soundData, DWORD dwSoundBytes);
public:
DSound(CMixer *mixer, void *hWnd = NULL)
: SoundStream(mixer)
, bufferSize(0)
, totalRenderedBytes(0)
, currentPos(0)
, lastPos(0)
, dsBuffer(0)

226
Source/Core/AudioCommon/Src/Mixer.cpp
View File

@ -16,112 +16,65 @@
// http://code.google.com/p/dolphin-emu/
// This queue solution is temporary. I'll implement something more efficient later.
#include <queue> // System
#include "Thread.h" // Common
#include "Atomic.h"
#include "Mixer.h"
#include "FixedSizeQueue.h"
#include "AudioCommon.h"
int CMixer::Mix(short *samples, int numSamples)
// Executed from sound stream thread
unsigned int CMixer::Mix(short* samples, unsigned int numSamples)
{
if (! samples) {
Premix(NULL, 0);
if (!samples)
return 0;
}
// silence
memset(samples, 0, numSamples * 2 * sizeof(short));
if (g_dspInitialize.pEmulatorState) {
if (g_dspInitialize.pEmulatorState)
{
if (*g_dspInitialize.pEmulatorState != 0)
return 0;
}
// first get the DTK Music
if (m_EnableDTKMusic) {
g_dspInitialize.pGetAudioStreaming(samples, numSamples);
}
Premix(samples, numSamples);
int count = 0;
push_sync.Enter();
while (m_queueSize > queue_minlength && count < numSamples * 2)
{
int x = samples[count];
x += sample_queue.front();
if (x > 32767) x = 32767;
if (x < -32767) x = -32767;
samples[count++] = x;
sample_queue.pop();
x = samples[count];
x += sample_queue.front();
if (x > 32767) x = 32767;
if (x < -32767) x = -32767;
samples[count++] = x;
sample_queue.pop();
m_queueSize-=2;
}
push_sync.Leave();
return count;
}
void CMixer::PushSamples(short *samples, int num_stereo_samples, int core_sample_rate)
{
push_sync.Enter();
if (m_queueSize == 0)
{
m_queueSize = queue_minlength;
for (int i = 0; i < queue_minlength; i++)
sample_queue.push((s16)0);
}
push_sync.Leave();
#ifdef _WIN32
if (GetAsyncKeyState(VK_TAB))
return;
#endif
// Write Other Audio
if (!m_throttle)
return;
// -----------------------------------------------------------------------
// The auto throttle function. This loop will put a ceiling on the CPU MHz.
// ----------------------------
/* This is only needed for non-AX sound, currently directly
streamed and DTK sound. For AX we call SoundStream::Update in
AXTask() for example. */
while (m_queueSize > queue_maxlength / 2)
{
// Urgh.
if (g_dspInitialize.pEmulatorState) {
if (*g_dspInitialize.pEmulatorState != 0)
return;
{
// Silence
memset(samples, 0, numSamples * 4);
return numSamples;
}
soundStream->Update();
SLEEP(1);
}
// -----------------------------------------------------------------------
push_sync.Enter();
while (num_stereo_samples)
unsigned int numLeft = Common::AtomicLoad(m_numSamples);
numLeft = (numLeft > numSamples) ? numSamples : numLeft;
// Do re-sampling if needed
if (m_sampleRate == m_dspSampleRate)
{
sample_queue.push(Common::swap16(*samples));
samples++;
sample_queue.push(Common::swap16(*samples));
samples++;
m_queueSize += 2;
num_stereo_samples--;
for (unsigned int i = 0; i < numLeft * 2; i++)
samples[i] = Common::swap16(m_buffer[(m_indexR + i) & INDEX_MASK]);
m_indexR += numLeft * 2;
}
push_sync.Leave();
return;
else if (m_sampleRate < m_dspSampleRate) // If down-sampling needed
{
_dbg_assert_msg_(DSPHLE, !(numSamples % 2), "Number of Samples: %i must be even!", numSamples);
short *pDest = samples;
int last_l, last_r, cur_l, cur_r;
for (unsigned int i = 0; i < numLeft * 3 / 2; i++)
{
cur_l = Common::swap16(m_buffer[(m_indexR + i * 2) & INDEX_MASK]);
cur_r = Common::swap16(m_buffer[(m_indexR + i * 2 + 1) & INDEX_MASK]);
if (i % 3)
{
*pDest++ = (last_l + cur_r) / 2;
*pDest++ = (last_r + cur_r) / 2;
}
last_l = cur_l;
last_r = cur_r;
}
m_indexR += numLeft * 2 * 3 / 2;
}
else if (m_sampleRate > m_dspSampleRate)
{
// AyuanX: Up-sampling is not implemented yet
PanicAlert("Mixer: Up-sampling is not implemented yet!");
/*
static int PV1l=0,PV2l=0,PV3l=0,PV4l=0;
static int PV1r=0,PV2r=0,PV3r=0,PV4r=0;
@ -183,16 +136,93 @@ void CMixer::PushSamples(short *samples, int num_stereo_samples, int core_sample
sample_queue.push(r);
m_queueSize += 2;
}
push_sync.Leave();
*/
}
// Padding
if (numSamples > numLeft)
memset(&samples[numLeft * 2], 0, (numSamples - numLeft) * 4);
// Add the HLE sound
if (m_sampleRate < m_dspSampleRate)
{
PanicAlert("Mixer: DSPHLE down-sampling is not implemented yet!\n"
"Usually no game should require this, please report!");
}
else
{
Premix(samples, numSamples, m_sampleRate);
}
// Add the DTK Music
if (m_EnableDTKMusic)
{
// Re-sampling is done inside
g_dspInitialize.pGetAudioStreaming(samples, numSamples, m_sampleRate);
}
Common::AtomicAdd(m_numSamples, -(int)numLeft);
return numSamples;
}
int CMixer::GetNumSamples()
void CMixer::PushSamples(short *samples, unsigned int num_samples, unsigned int sample_rate)
{
return m_queueSize / 2;
//int ret = (m_queueSize - queue_minlength) / 2;
//ret = (ret > 0) ? ret : 0;
//return ret;
// The auto throttle function. This loop will put a ceiling on the CPU MHz.
if (m_throttle)
{
// AyuanX: Remember to reserve "num_samples * 1.5" free sample space at least!
// Becuse we may do re-sampling later
while (Common::AtomicLoad(m_numSamples) >= MAX_SAMPLES - RESERVED_SAMPLES)
{
if (g_dspInitialize.pEmulatorState)
{
if (*g_dspInitialize.pEmulatorState != 0)
break;
}
soundStream->Update();
SLEEP(1);
}
}
// Check if we have enough free space
if (num_samples > MAX_SAMPLES - Common::AtomicLoad(m_numSamples))
return;
// AyuanX: Actual re-sampling work has been moved to sound thread
// to alleviates the workload on main thread
// and we simply store raw data here to make fast mem copy
int over_bytes = num_samples * 4 - (MAX_SAMPLES * 2 - (m_indexW & INDEX_MASK)) * sizeof(short);
if (over_bytes > 0)
{
memcpy(&m_buffer[m_indexW & INDEX_MASK], samples, num_samples * 4 - over_bytes);
memcpy(&m_buffer[0], samples + (num_samples * 4 - over_bytes) / sizeof(short), over_bytes);
}
else
{
memcpy(&m_buffer[m_indexW & INDEX_MASK], samples, num_samples * 4);
}
m_indexW += num_samples * 2;
if (m_sampleRate < m_dspSampleRate)
{
// This is kind of tricky :P
num_samples = num_samples * 2 / 3;
}
else if (m_sampleRate > m_dspSampleRate)
{
PanicAlert("Mixer: Up-sampling is not implemented yet!");
}
Common::AtomicAdd(m_numSamples, num_samples);
return;
}
unsigned int CMixer::GetNumSamples()
{
return Common::AtomicLoad(m_numSamples);
}

57
Source/Core/AudioCommon/Src/Mixer.h
View File

@ -18,39 +18,38 @@
#ifndef _MIXER_H_
#define _MIXER_H_
#include "FixedSizeQueue.h"
#include "Thread.h"
// On real hardware, this fifo is much, much smaller. But timing is also
// tighter than under Windows, so...
#define queue_minlength 1024 * 4
#define queue_maxlength 1024 * 28
// 16 bit Stereo
#define MAX_SAMPLES (1024 * 4)
#define INDEX_MASK (MAX_SAMPLES * 2 - 1)
#define RESERVED_SAMPLES (MAX_SAMPLES / 8)
class CMixer {
public:
// AyuanX: Mixer sample rate is fixed to 32khz for now
// if any game sets DSP sample rate to 48khz, we are doomed
// TODO: Fix this somehow!
CMixer(unsigned int SampleRate = 32000)
: m_sampleRate(SampleRate)
CMixer(unsigned int AISampleRate = 48000, unsigned int DSPSampleRate = 48000)
: m_aiSampleRate(AISampleRate)
, m_dspSampleRate(DSPSampleRate)
, m_bits(16)
, m_channels(2)
, m_mode(2)
, m_HLEready(false)
, m_queueSize(0)
{}
, m_numSamples(0)
, m_indexW(0)
, m_indexR(0)
{
// AyuanX: When sample rate differs, we have to do re-sampling
// I perfer speed so let's do down-sampling instead of up-sampling
// If you like better sound than speed, feel free to implement the up-sampling code
m_sampleRate = (m_aiSampleRate < m_dspSampleRate) ? m_aiSampleRate : m_dspSampleRate;
}
// Called from audio threads
virtual int Mix(short *sample, int numSamples);
virtual int GetNumSamples();
virtual unsigned int Mix(short* samples, unsigned int numSamples);
virtual void Premix(short *samples, unsigned int numSamples, unsigned int sampleRate) {}
unsigned int GetNumSamples();
// Called from main thread
virtual void PushSamples(short* samples, int num_stereo_samples, int core_sample_rate);
virtual void Premix(short *samples, int numSamples) {}
int GetSampleRate() {return m_sampleRate;}
virtual void PushSamples(short* samples, unsigned int num_samples, unsigned int sample_rate);
unsigned int GetSampleRate() {return m_sampleRate;}
void SetThrottle(bool use) { m_throttle = use;}
void SetDTKMusic(bool use) { m_EnableDTKMusic = use;}
@ -61,19 +60,23 @@ public:
// ---------------------
protected:
int m_sampleRate;
unsigned int m_sampleRate;
unsigned int m_aiSampleRate;
unsigned int m_dspSampleRate;
int m_bits;
int m_channels;
int m_mode;
bool m_HLEready;
int m_queueSize;
bool m_EnableDTKMusic;
bool m_throttle;
short m_buffer[MAX_SAMPLES * 2];
u32 m_indexW;
u32 m_indexR;
volatile u32 m_numSamples;
private:
Common::CriticalSection push_sync;
FixedSizeQueue<s16, queue_maxlength> sample_queue;
};

9
Source/Core/AudioCommon/Src/NullSoundStream.h
View File

@ -22,10 +22,10 @@
#include "Mixer.h"
class NullMixer : public CMixer {
public:
virtual int Mix(short *sample, int numSamples) {return 0;}
virtual void PushSamples(short* samples, int num_stereo_samples,
int core_sample_rate) {}
virtual unsigned int Mix(short *samples, unsigned int numSamples) { return 0; }
virtual void PushSamples(short* samples, unsigned int num_samples, unsigned int sample_rate) {}
};
class NullSound : public SoundStream
@ -35,7 +35,6 @@ public:
{
delete m_mixer;
m_mixer = new NullMixer();
}
virtual ~NullSound() {}
@ -47,7 +46,7 @@ public:
virtual bool Start() { return true; }
virtual void Update() {
m_mixer->Mix(NULL, 256 >> 2);
//m_mixer->Mix(NULL, 256 >> 2);
//(*callback)(NULL, 256 >> 2, 16, sampleRate, 2);
}
};

19
Source/Core/AudioCommon/Src/OpenALStream.cpp
View File

@ -138,12 +138,13 @@ void OpenALStream::SoundLoop()
// Generate a Source to playback the Buffers
alGenSources(1, &uiSource);
memset(realtimeBuffer, 0, OAL_BUFFER_SIZE);
// Short Silence
memset(realtimeBuffer, 0, OAL_MAX_SAMPLES * 4);
for (int i = 0; i < OAL_NUM_BUFFERS; i++)
alBufferData(uiBuffers[i], AL_FORMAT_STEREO16, realtimeBuffer, OAL_BUFFER_SIZE, ulFrequency);
alBufferData(uiBuffers[i], AL_FORMAT_STEREO16, realtimeBuffer, OAL_MAX_SAMPLES, ulFrequency);
alSourceQueueBuffers(uiSource, OAL_NUM_BUFFERS, uiBuffers);
alSourcePlay(uiSource);
err = alGetError();
// TODO: Error handling
@ -158,12 +159,12 @@ void OpenALStream::SoundLoop()
alGetSourcei(uiSource, AL_BUFFERS_PROCESSED, &iBuffersProcessed);
iBuffersFilled = 0;
}
int numSamples = m_mixer->GetNumSamples();
numSamples &= ~0x100;
if (iBuffersProcessed && numSamples)
unsigned int numSamples = m_mixer->GetNumSamples();
if (iBuffersProcessed && (numSamples >= OAL_THRESHOLD))
{
numSamples = (numSamples > OAL_BUFFER_SIZE / 4) ? OAL_BUFFER_SIZE / 4 : numSamples;
numSamples = (numSamples > OAL_MAX_SAMPLES) ? OAL_MAX_SAMPLES : numSamples;
// Remove the Buffer from the Queue. (uiBuffer contains the Buffer ID for the unqueued Buffer)
if (iBuffersFilled == 0)
alSourceUnqueueBuffers(uiSource, iBuffersProcessed, uiBufferTemp);
@ -176,11 +177,11 @@ void OpenALStream::SoundLoop()
if (iBuffersFilled == OAL_NUM_BUFFERS)
alSourcePlay(uiSource);
}
else
else if (numSamples >= OAL_THRESHOLD)
{
ALint state = 0;
alGetSourcei(uiSource, AL_SOURCE_STATE, &state);
if (state != AL_PLAYING)
if (state == AL_STOPPED)
alSourcePlay(uiSource);
}
soundSyncEvent.Wait();

7
Source/Core/AudioCommon/Src/OpenALStream.h
View File

@ -33,10 +33,11 @@
#include "AL/al.h"
#include "AL/alc.h"
#endif // WIN32
// public use
// 16 bit Stereo
#define SFX_MAX_SOURCE 1
#define OAL_NUM_BUFFERS 8
#define OAL_BUFFER_SIZE (512 * 4)
#define OAL_MAX_SAMPLES 512 // AyuanX: Don't make it too large, as larger buffer means longer delay
#define OAL_THRESHOLD 128
#endif
class OpenALStream: public SoundStream
@ -66,7 +67,7 @@ private:
Common::CriticalSection soundCriticalSection;
Common::Event soundSyncEvent;
short realtimeBuffer[OAL_BUFFER_SIZE/sizeof(short)];
short realtimeBuffer[OAL_MAX_SAMPLES * 2];
ALuint uiBuffers[OAL_NUM_BUFFERS];
ALuint uiSource;
ALfloat fVolume;

2
Source/Core/Common/Src/PluginDSP.h
View File

@ -27,7 +27,7 @@ typedef void (__cdecl* TDSP_WriteMailBox)(bool _CPUMailbox, unsigned short);
typedef unsigned short (__cdecl* TDSP_ReadMailBox)(bool _CPUMailbox);
typedef unsigned short (__cdecl* TDSP_ReadControlRegister)();
typedef unsigned short (__cdecl* TDSP_WriteControlRegister)(unsigned short);
typedef void (__cdecl *TDSP_SendAIBuffer)(unsigned int address, int sample_rate);
typedef void (__cdecl *TDSP_SendAIBuffer)(unsigned int address, unsigned int num_samples, unsigned int sample_rate);
typedef void (__cdecl *TDSP_Update)(int cycles);
typedef void (__cdecl *TDSP_StopSoundStream)();
typedef void (__cdecl *TDSP_ClearAudioBuffer)();

2
Source/Core/Core/Src/ConfigManager.cpp
View File

@ -234,7 +234,7 @@ void SConfig::LoadSettings()
ini.Get("Core", "RunCompareServer", &m_LocalCoreStartupParameter.bRunCompareServer, false);
ini.Get("Core", "RunCompareClient", &m_LocalCoreStartupParameter.bRunCompareClient, false);
ini.Get("Core", "TLBHack", &m_LocalCoreStartupParameter.iTLBHack, 0);
ini.Get("Core", "FrameLimit", &m_Framelimit, 1);
ini.Get("Core", "FrameLimit", &m_Framelimit, 0); // auto frame limit by default
// Plugins
ini.Get("Core", "GFXPlugin", &m_LocalCoreStartupParameter.m_strVideoPlugin, m_DefaultGFXPlugin.c_str());

1
Source/Core/Core/Src/Core.cpp
View File

@ -386,6 +386,7 @@ THREAD_RETURN EmuThread(void *pArg)
dspInit.pDebuggerBreak = Callback_DebuggerBreak;
dspInit.pGenerateDSPInterrupt = Callback_DSPInterrupt;
dspInit.pGetAudioStreaming = AudioInterface::Callback_GetStreaming;
dspInit.pGetSampleRate = AudioInterface::Callback_GetSampleRate;
dspInit.pEmulatorState = (int *)PowerPC::GetStatePtr();
dspInit.bWii = _CoreParameter.bWii;
dspInit.bOnThread = _CoreParameter.bDSPThread;

66
Source/Core/Core/Src/HW/AudioInterface.cpp
View File

@ -54,13 +54,13 @@ union AICR
struct
{
unsigned PSTAT : 1; // sample counter/playback enable
unsigned AFR : 1; // 0=32khz 1=48khz
unsigned AFR : 1; // AI Frequency (0=32khz 1=48khz)
unsigned AIINTMSK : 1; // 0=interrupt masked 1=interrupt enabled
unsigned AIINT : 1; // audio interrupt status
unsigned AIINTVLD : 1; // This bit controls whether AIINT is affected by the AIIT register
// matching AISLRCNT. Once set, AIINT will hold
unsigned SCRESET : 1; // write to reset counter
unsigned DSPFR : 1; // DSP Frequency (0=48khz 1=32khz) WTF, who designed this?
unsigned DSPFR : 1; // DSP Frequency (0=48khz 1=32khz)
unsigned :25;
};
u32 hex;
@ -90,8 +90,8 @@ struct SAudioRegister
// STATE_TO_SAVE
static SAudioRegister g_AudioRegister;
static u64 g_LastCPUTime = 0;
static int g_SampleRate = 32000;
static int g_DSPSampleRate = 32000;
static unsigned int g_SampleRate = 32000;
static unsigned int g_DSPSampleRate = 32000;
static u64 g_CPUCyclesPerSample = 0xFFFFFFFFFFFULL;
void DoState(PointerWrap &p)
@ -264,9 +264,15 @@ void GenerateAudioInterrupt()
UpdateInterrupts();
}
void Callback_GetSampleRate(unsigned int &_AISampleRate, unsigned int &_DSPSampleRate)
{
_AISampleRate = g_SampleRate;
_DSPSampleRate = g_DSPSampleRate;
}
// Callback for the disc streaming
// WARNING - called from audio thread
u32 Callback_GetStreaming(short* _pDestBuffer, u32 _numSamples)
unsigned int Callback_GetStreaming(short* _pDestBuffer, unsigned int _numSamples, unsigned int _sampleRate)
{
if (g_AudioRegister.m_Control.PSTAT && !CCPU::IsStepping())
{
@ -275,34 +281,60 @@ u32 Callback_GetStreaming(short* _pDestBuffer, u32 _numSamples)
const int lvolume = g_AudioRegister.m_Volume.leftVolume;
const int rvolume = g_AudioRegister.m_Volume.rightVolume;
// AyuanX: I hate this, but for now we have to do down-sampling to support 48khz
if (g_SampleRate == 48000)
if (g_SampleRate == 48000 && _sampleRate == 32000)
{
_dbg_assert_msg_(AUDIO_INTERFACE, !(_numSamples % 2), "Number of Samples: %i must be even!", _numSamples);
_numSamples = _numSamples * 3 / 2;
}
else if (g_SampleRate == 32000 && _sampleRate == 48000)
{
// AyuanX: Up-sampling is not implemented yet
PanicAlert("AUDIO_INTERFACE: Up-sampling is not implemented yet!");
}
short pcm_l = 0;
short pcm_r = 0;
int pcm_l, pcm_r;
for (unsigned int i = 0; i < _numSamples; i++)
{
if (pos == 0)
ReadStreamBlock(pcm);
if (g_SampleRate == 48000)
if (g_SampleRate == 48000 && _sampleRate == 32000)
{
if (i % 3)
{
*_pDestBuffer++ = ((pcm_l / 2 + pcm[pos*2] / 2) * lvolume) >> 8;
*_pDestBuffer++ = ((pcm_r / 2 + pcm[pos*2+1] / 2) * rvolume) >> 8;
pcm_l = (((pcm_l + (int)pcm[pos*2]) / 2 * lvolume) >> 8) + (int)(*_pDestBuffer);
if (pcm_l > 32767)
pcm_l = 32767;
else if (pcm_l < -32767)
pcm_l = -32767;
*_pDestBuffer++ = pcm_l;
pcm_r = (((pcm_r + (int)pcm[pos*2+1]) / 2 * rvolume) >> 8) + (int)(*_pDestBuffer);
if (pcm_r > 32767)
pcm_r = 32767;
else if (pcm_r < -32767)
pcm_r = -32767;
*_pDestBuffer++ = pcm_r;
}
pcm_l = pcm[pos*2];
pcm_r = pcm[pos*2+1];
}
else
{
*_pDestBuffer++ = (pcm[pos*2] * lvolume) >> 8;
*_pDestBuffer++ = (pcm[pos*2+1] * rvolume) >> 8;
pcm_l = (((int)pcm[pos*2] * lvolume) >> 8) + (int)(*_pDestBuffer);
if (pcm_l > 32767)
pcm_l = 32767;
else if (pcm_l < -32767)
pcm_l = -32767;
*_pDestBuffer++ = pcm_l;
pcm_r = (((int)pcm[pos*2+1] * rvolume) >> 8) + (int)(*_pDestBuffer);
if (pcm_r > 32767)
pcm_r = 32767;
else if (pcm_r < -32767)
pcm_r = -32767;
*_pDestBuffer++ = pcm_r;
}
if (++pos == 28)
@ -311,7 +343,7 @@ u32 Callback_GetStreaming(short* _pDestBuffer, u32 _numSamples)
}
else
{
// AyuanX: We have already preset those bytes, no need to do this again
// Don't overwrite existed sample data
/*
for (unsigned int i = 0; i < _numSamples * 2; i++)
{
@ -361,12 +393,12 @@ void IncreaseSampleCount(const u32 _iAmount)
}
}
u32 GetAISampleRate()
unsigned int GetAISampleRate()
{
return g_SampleRate;
}
u32 GetDSPSampleRate()
unsigned int GetDSPSampleRate()
{
return g_DSPSampleRate;
}

7
Source/Core/Core/Src/HW/AudioInterface.h
View File

@ -34,14 +34,15 @@ void DoState(PointerWrap &p);
void Update();
// Called by DSP plugin
u32 Callback_GetStreaming(short* _pDestBuffer, u32 _numSamples);
void Callback_GetSampleRate(unsigned int &_AISampleRate, unsigned int &_DSPSampleRate);
unsigned int Callback_GetStreaming(short* _pDestBuffer, unsigned int _numSamples, unsigned int _sampleRate = 48000);
void Read32(u32& _uReturnValue, const u32 _iAddress);
void Write32(const u32 _iValue, const u32 _iAddress);
// Get the audio rates (48000 or 32000 only)
u32 GetAISampleRate();
u32 GetDSPSampleRate();
unsigned int GetAISampleRate();
unsigned int GetDSPSampleRate();
} // namespace

33
Source/Core/Core/Src/HW/DSP.cpp
View File

@ -197,7 +197,6 @@ static u16 g_AR_SIZE;
static u16 g_AR_MODE;
static u16 g_AR_REFRESH;
Common::PluginDSP *dsp_plugin;
@ -379,27 +378,6 @@ void Write16(const u16 _Value, const u32 _Address)
g_dspState.DSPControl.DSPHalt = tmpControl.DSPHalt;
g_dspState.DSPControl.DSPInit = tmpControl.DSPInit;
// AyuanX: WTF, sample rate between AI & DSP can be different?
// This is a big problem especially when our mixer is fixed to 32000
// TODO: Try to support these!
// More info: AudioCommon/Mixer.h, HW/AudioInterface.cpp
static bool FirstTimeWarning = false;
if (!FirstTimeWarning)
{
if (!g_dspState.DSPControl.DSPHalt && g_dspState.DSPControl.DSPInit)
{
// It's time to check now, and we do this only once
FirstTimeWarning = true;
if (AudioInterface::GetAISampleRate() != 32000 || AudioInterface::GetDSPSampleRate() != 32000)
{
WARN_LOG(DSPINTERFACE, "Unsupported Sample Rate, AI:%i, DSP:%i", AudioInterface::GetAISampleRate(), AudioInterface::GetDSPSampleRate());
if (AudioInterface::GetDSPSampleRate() != 32000)
PanicAlert("DSPINTERFACE: Unsupported Sample Rate, AI:%i, DSP:%i\n"
"You may get incorrect sound output, please report!", AudioInterface::GetAISampleRate(), AudioInterface::GetDSPSampleRate());
}
}
}
// Interrupt (mask)
g_dspState.DSPControl.AID_mask = tmpControl.AID_mask;
g_dspState.DSPControl.ARAM_mask = tmpControl.ARAM_mask;
@ -503,12 +481,17 @@ void UpdateAudioDMA()
// external audio fifo in the emulator, to be mixed with the disc
// streaming output. If that audio queue fills up, we delay the
// emulator.
dsp_plugin->DSP_SendAIBuffer(g_audioDMA.ReadAddress, AudioInterface::GetDSPSampleRate());
g_audioDMA.ReadAddress += 32;
// AyuanX: let's do it in a bundle to speed up
if (g_audioDMA.BlocksLeft == g_audioDMA.AudioDMAControl.NumBlocks)
dsp_plugin->DSP_SendAIBuffer(g_audioDMA.SourceAddress, g_audioDMA.AudioDMAControl.NumBlocks * 8, AudioInterface::GetDSPSampleRate());
// g_audioDMA.ReadAddress += 32;
g_audioDMA.BlocksLeft--;
if (g_audioDMA.BlocksLeft == 0)
{
g_audioDMA.ReadAddress = g_audioDMA.SourceAddress;
// g_audioDMA.ReadAddress = g_audioDMA.SourceAddress;
g_audioDMA.BlocksLeft = g_audioDMA.AudioDMAControl.NumBlocks;
// DEBUG_LOG(DSPLLE, "ADMA read addresses: %08x", g_audioDMA.ReadAddress);
GenerateDSPInterrupt(DSP::INT_AID);

2
Source/Core/Core/Src/HW/MemmapFunctions.cpp
View File

@ -590,7 +590,7 @@ void GenerateISIException()
// segment (N bit set in segment descriptor), or to guarded memory
// when MSR[IR] = 1. Otherwise, cleared.
// Bit 4: Set if a memory access is not permitted by the page or IBAT protection
// mechanism, described in Chapter 7, <EFBFBD>Memory Management<EFBFBD>; otherwise cleared.
// mechanism, described in Chapter 7, "Memory Management" otherwise cleared.
// Only one of 1,3, or 4 may be set at a time
// For now let's just say that hash lookup failed