hrydgard 419d6a244b DSP plugin merge - the two DSP plugins are now gone and all the code has been merged into Dolphin.
This WILL temporarily break the Linux and MacOSX builds but should be easy to fix.

Things left to do:
  * The UI on the new Audio tab for the LLE/HLE choice is ugly
  * At times the code still look "plugin-y" and needs cleanup
  * The two plugins should be merged further. DSPHLE should use the emulated memory etc of DSPLLE as much as possible, so that simply saving the DSPLLE state is enough. This would also bring the possibility of savestate compatibility between the two plugins.


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6947 8ced0084-cf51-0410-be5f-012b33b47a6e
2011-01-28 18:39:30 +00:00

194 lines
5.2 KiB
C++

// Copyright (C) 2003 Dolphin Project.
// This program 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, version 2.0.
// This program 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 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "Atomic.h"
#include "Mixer.h"
#include "AudioCommon.h"
#include "CPUDetect.h"
#include "../../Core/Src/HW/AudioInterface.h"
// UGLINESS
#include "../../Core/Src/PowerPC/PowerPC.h"
#if _M_SSE >= 0x301 && !(defined __GNUC__ && !defined __SSSE3__)
#include <tmmintrin.h>
#endif
static const __m128i sr_mask = _mm_set_epi32(0x0C0D0E0FL, 0x08090A0BL, 0x04050607L, 0x00010203L);
// Executed from sound stream thread
unsigned int CMixer::Mix(short* samples, unsigned int numSamples)
{
if (!samples)
return 0;
if (PowerPC::GetState() != 0)
{
// Silence
memset(samples, 0, numSamples * 4);
return numSamples;
}
unsigned int numLeft = Common::AtomicLoad(m_numSamples);
if (m_AIplaying) {
if (numLeft < numSamples)//cannot do much about this
m_AIplaying = false;
if (numLeft < MAX_SAMPLES/4)//low watermark
m_AIplaying = false;
} else {
if (numLeft > MAX_SAMPLES/2)//high watermark
m_AIplaying = true;
}
if (m_AIplaying) {
numLeft = (numLeft > numSamples) ? numSamples : numLeft;
// Do re-sampling if needed
if (m_sampleRate == 32000)
{
#if _M_SSE >= 0x301
if (cpu_info.bSSSE3 && !((numLeft * 2) % 8))
{
for (unsigned int i = 0; i < numLeft * 2; i += 8)
{
_mm_storeu_si128((__m128i *)&samples[i], _mm_shuffle_epi8(_mm_loadu_si128((__m128i *)&m_buffer[(m_indexR + i) & INDEX_MASK]), sr_mask));
}
}
else
#endif
{
for (unsigned int i = 0; i < numLeft * 2; i+=2)
{
samples[i] = Common::swap16(m_buffer[(m_indexR + i + 1) & INDEX_MASK]);
samples[i+1] = Common::swap16(m_buffer[(m_indexR + i) & INDEX_MASK]);
}
}
m_indexR += numLeft * 2;
}
else //linear interpolation
{
//render numleft sample pairs to samples[]
//advance m_indexR with sample position
//remember fractional offset
static u32 frac = 0;
const u32 ratio = (u32)( 65536.0f * 32000.0f / (float)m_sampleRate );
for (u32 i = 0; i < numLeft * 2; i+=2) {
u32 m_indexR2 = m_indexR + 2; //next sample
if ((m_indexR2 & INDEX_MASK) == (m_indexW & INDEX_MASK)) //..if it exists
m_indexR2 = m_indexR;
s16 l1 = Common::swap16(m_buffer[m_indexR & INDEX_MASK]); //current
s16 l2 = Common::swap16(m_buffer[m_indexR2 & INDEX_MASK]); //next
int sampleL = ((l1 << 16) + (l2 - l1) * (u16)frac) >> 16;
samples[i+1] = sampleL;
s16 r1 = Common::swap16(m_buffer[(m_indexR + 1) & INDEX_MASK]); //current
s16 r2 = Common::swap16(m_buffer[(m_indexR2 + 1) & INDEX_MASK]); //next
int sampleR = ((r1 << 16) + (r2 - r1) * (u16)frac) >> 16;
samples[i] = sampleR;
frac += ratio;
m_indexR += 2 * (u16)(frac >> 16);
frac &= 0xffff;
}
}
} else {
numLeft = 0;
}
// Padding
if (numSamples > numLeft)
memset(&samples[numLeft * 2], 0, (numSamples - numLeft) * 4);
// Add the DSPHLE sound, re-sampling is done inside
Premix(samples, numSamples);
// Add the DTK Music
if (m_EnableDTKMusic)
{
// Re-sampling is done inside
AudioInterface::Callback_GetStreaming(samples, numSamples, m_sampleRate);
}
Common::AtomicAdd(m_numSamples, -(s32)numLeft);
return numSamples;
}
void CMixer::PushSamples(const short *samples, unsigned int num_samples)
{
if (m_throttle)
{
// The auto throttle function. This loop will put a ceiling on the CPU MHz.
while (num_samples + Common::AtomicLoad(m_numSamples) > MAX_SAMPLES)
{
if (*PowerPC::GetStatePtr() != 0)
break;
// Shortcut key for Throttle Skipping
#ifdef _WIN32
if (GetAsyncKeyState(VK_TAB)) break;;
#endif
SLEEP(1);
soundStream->Update();
}
}
// Check if we have enough free space
if (num_samples + Common::AtomicLoad(m_numSamples) > MAX_SAMPLES)
return;
// AyuanX: Actual re-sampling work has been moved to sound thread
// to alleviate 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 == 32000)
Common::AtomicAdd(m_numSamples, num_samples);
else if (m_sampleRate == 48000)
Common::AtomicAdd(m_numSamples, num_samples * 3 / 2);
else
PanicAlertT("Mixer: Unsupported sample rate.");
return;
}
unsigned int CMixer::GetNumSamples()
{
return Common::AtomicLoad(m_numSamples);
}